elsabro 2.1.0 → 2.3.0

package/commands/elsabro/execute.md

@@ -13,22 +13,225 @@ allowed-tools:
   - TaskUpdate
   - TaskList
   - TaskGet
+  - AskUserQuestion
   - mcp__plugin_context7_context7__*
 argument-hint: "[número de fase]"
+sync:
+  reads: [".elsabro/state.json", ".planning/*-PLAN.md"]
+  writes: [".elsabro/state.json", ".elsabro/context.md"]
+  phases: ["initializing", "exploring", "executing_wave_N", "verifying", "done"]
+  passes_context_to: ["verify-work"]
+dispatcher:
+  exploration:
+    agents: [Explore, feature-dev:code-explorer, Plan]
+    model: haiku
+    parallel: true
+    min_agents: 3
+  implementation:
+    agents: [elsabro-executor, feature-dev:code-architect]
+    model: opus
+    parallel: true
+    min_agents: 2
+  verification:
+    agents: [pr-review-toolkit:code-reviewer, pr-review-toolkit:silent-failure-hunter, pr-review-toolkit:pr-test-analyzer]
+    model: opus
+    parallel: true
+    min_agents: 3
 ---
 
 # ELSABRO: Execute
 
+<state_sync>
+## SINCRONIZACIÓN DE ESTADO (OBLIGATORIO)
+
+**IMPORTAR**: Este comando DEBE seguir `/references/state-sync.md` y `/references/enforcement-rules.md`.
+
+### Al Iniciar (ANTES de cualquier operación)
+
+```javascript
+// 1. Crear task de inicialización
+TaskCreate({
+  subject: "Initialize execute command",
+  description: "Leer estado y preparar ejecución",
+  activeForm: "Inicializando..."
+})
+TaskUpdate(id, status: "in_progress")
+
+// 2. Leer estado existente
+const state = Read(".elsabro/state.json") || createInitialState();
+
+// 3. Verificar flujo en progreso
+if (state.current_flow && state.current_flow.command !== "execute") {
+  AskUserQuestion({
+    questions: [{
+      question: `Hay un flujo de "${state.current_flow.command}" en progreso. ¿Continuar ese o empezar execute?`,
+      header: "Flujo",
+      options: [
+        { label: "Continuar anterior", description: "Retomar " + state.current_flow.command },
+        { label: "Empezar execute", description: "Pausar anterior" }
+      ]
+    }]
+  });
+}
+
+// 4. Actualizar estado
+state.current_flow = { command: "execute", phase: "initializing", started_at: new Date().toISOString() };
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+// 5. Completar task de inicialización
+TaskUpdate(id, status: "completed")
+```
+
+### Al Cambiar de Fase
+
+```javascript
+// Antes de exploración
+state.current_flow.phase = "exploring";
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+// Antes de cada wave
+state.current_flow.phase = "executing_wave_" + waveNumber;
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+// Antes de verificación
+state.current_flow.phase = "verifying";
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+```
+
+### Al Completar
+
+```javascript
+// Registrar en historial
+state.history.push({
+  command: "execute",
+  completed_at: new Date().toISOString(),
+  result: "completed_phase_" + phaseNumber,
+  artifact: null
+});
+
+// Pasar contexto a verify-work
+state.context.changed_files = [...changedFiles];
+state.context.commits = [...commitIds];
+state.context.tests_added = [...testFiles];
+state.context.phase_completed = phaseNumber;
+
+// Limpiar flujo y sugerir siguiente
+state.current_flow = null;
+state.suggested_next = "verify-work";
+
+Write(".elsabro/state.json", JSON.stringify(state, null, 2));
+
+// Actualizar context.md legible
+Write(".elsabro/context.md", generateHumanReadableContext(state));
+```
+</state_sync>
+
 <objective>
 Ejecutar planes de una fase con:
 - **Sistema de Tasks para tracking real** de waves y dependencias
+- **Dispatcher inteligente con selección automática de modelo** (ver @references/task-dispatcher.md)
+- **Ejecución por subagentes en paralelo** según tipo de tarea
 - Investigación de patrones con Context7
 - TDD cuando sea apropiado
 - Commits atómicos por tarea
 - Verificación automática con agregador
 </objective>
 
+<dispatcher_integration>
+## Selección Automática de Modelo
+
+**REGLA CRÍTICA:** Cada tarea se ejecuta con el modelo óptimo para su tipo.
+
+```
+┌─────────────────────────────────────────────────────────────────────────┐
+│                    MODELO SEGÚN FASE                                     │
+├─────────────────────────────────────────────────────────────────────────┤
+│  FASE              │  SUBAGENTES                        │  MODELO       │
+├────────────────────┼────────────────────────────────────┼───────────────┤
+│  Exploración       │  Explore                           │  HAIKU        │
+│  (pre-ejecución)   │  feature-dev:code-explorer         │  HAIKU        │
+│                    │  Plan                              │  HAIKU        │
+│                    │  (3 en paralelo obligatorio)       │               │
+├────────────────────┼────────────────────────────────────┼───────────────┤
+│  Implementación    │  elsabro-executor                  │  OPUS         │
+│  (waves)           │  feature-dev:code-architect        │  OPUS         │
+│                    │  (2+ en paralelo por wave)         │               │
+├────────────────────┼────────────────────────────────────┼───────────────┤
+│  Verificación      │  pr-review-toolkit:code-reviewer   │  OPUS         │
+│  (post-ejecución)  │  pr-review-toolkit:silent-...      │  OPUS         │
+│                    │  pr-review-toolkit:pr-test-...     │  OPUS         │
+│                    │  (3 en paralelo obligatorio)       │               │
+└────────────────────┴────────────────────────────────────┴───────────────┘
+```
+
+### Por qué esta distribución
+
+- **HAIKU para exploración:** Solo lee y mapea, no necesita razonamiento profundo
+- **OPUS para implementación:** Escribe código, necesita máxima calidad
+- **OPUS para verificación:** Análisis profundo de bugs y edge cases
+</dispatcher_integration>
+
 <process>
+## Paso 0: Exploración Pre-Ejecución (HAIKU x3 paralelo)
+
+**OBLIGATORIO:** Antes de ejecutar, explorar el codebase para entender contexto.
+
+```javascript
+// Crear tasks de exploración
+TaskCreate({
+  subject: "Explore: Find related files",
+  description: "Buscar archivos relacionados con la fase",
+  activeForm: "Buscando archivos...",
+  metadata: { type: "exploration", model: "haiku" }
+})  // → explore-files-id
+
+TaskCreate({
+  subject: "Explore: Analyze patterns",
+  description: "Analizar patrones existentes en el codebase",
+  activeForm: "Analizando patrones...",
+  metadata: { type: "exploration", model: "haiku" }
+})  // → explore-patterns-id
+
+TaskCreate({
+  subject: "Explore: Map architecture",
+  description: "Mapear arquitectura del área afectada",
+  activeForm: "Mapeando arquitectura...",
+  metadata: { type: "exploration", model: "haiku" }
+})  // → explore-arch-id
+
+// Marcar todas como in_progress
+TaskUpdate({ taskId: "explore-files-id", status: "in_progress" })
+TaskUpdate({ taskId: "explore-patterns-id", status: "in_progress" })
+TaskUpdate({ taskId: "explore-arch-id", status: "in_progress" })
+
+// Lanzar 3 agentes HAIKU EN PARALELO (UN SOLO MENSAJE)
+Task({
+  subagent_type: "Explore",
+  model: "haiku",
+  description: "Buscar archivos relacionados",
+  prompt: "Busca archivos relacionados con la fase [N]. Lista los 10 más relevantes."
+}) |
+Task({
+  subagent_type: "feature-dev:code-explorer",
+  model: "haiku",
+  description: "Analizar patrones",
+  prompt: "Analiza patrones de arquitectura en el área de la fase [N]."
+}) |
+Task({
+  subagent_type: "Plan",
+  model: "haiku",
+  description: "Mapear arquitectura",
+  prompt: "Mapea componentes y flujo de datos del área afectada."
+})
+
+// Marcar completed
+TaskUpdate({ taskId: "explore-files-id", status: "completed" })
+TaskUpdate({ taskId: "explore-patterns-id", status: "completed" })
+TaskUpdate({ taskId: "explore-arch-id", status: "completed" })
+```
+
+**Resultado:** Contexto del codebase capturado antes de modificar nada.
+
 ## Paso 1: Descubrir Planes
 
 ```bash
@@ -93,26 +296,64 @@ Para cada wave:
 TaskUpdate({ taskId: "wave-W-id", status: "in_progress" })
 ```
 
-### Si hay múltiples planes en la wave → Paralelo
+### Si hay múltiples planes en la wave → Paralelo (OPUS)
 ```javascript
 // Marcar todos los planes como in_progress
 TaskUpdate({ taskId: "plan-A-id", status: "in_progress" })
 TaskUpdate({ taskId: "plan-B-id", status: "in_progress" })
 TaskUpdate({ taskId: "plan-C-id", status: "in_progress" })
 
-// Lanzar agentes en paralelo (UN SOLO MENSAJE)
-Task(elsabro-executor) para Plan A |
-Task(elsabro-executor) para Plan B |
-Task(elsabro-executor) para Plan C
+// Lanzar agentes OPUS en paralelo (UN SOLO MENSAJE)
+// MODELO: OPUS porque escriben código
+Task({
+  subagent_type: "elsabro-executor",
+  model: "opus",  // ← OPUS para implementación
+  description: "Ejecutar Plan A",
+  prompt: "Implementa el Plan A siguiendo TDD..."
+}) |
+Task({
+  subagent_type: "elsabro-executor",
+  model: "opus",  // ← OPUS para implementación
+  description: "Ejecutar Plan B",
+  prompt: "Implementa el Plan B siguiendo TDD..."
+}) |
+Task({
+  subagent_type: "elsabro-executor",
+  model: "opus",  // ← OPUS para implementación
+  description: "Ejecutar Plan C",
+  prompt: "Implementa el Plan C siguiendo TDD..."
+})
 
 // Al completar cada plan
 TaskUpdate({ taskId: "plan-A-id", status: "completed" })
 ```
 
-### Si solo hay un plan → Secuencial
+### Validación arquitectónica en paralelo (OPUS x2)
+```javascript
+// Además de implementar, validar arquitectura en paralelo
+Task({
+  subagent_type: "elsabro-executor",
+  model: "opus",
+  description: "Implementar cambios",
+  prompt: "..."
+}) |
+Task({
+  subagent_type: "feature-dev:code-architect",
+  model: "opus",  // ← OPUS para decisiones arquitectónicas
+  description: "Validar arquitectura",
+  prompt: "Verifica que la implementación sigue los patrones del codebase..."
+})
+```
+
+### Si solo hay un plan → Secuencial (OPUS)
 ```javascript
 TaskUpdate({ taskId: "plan-X-id", status: "in_progress" })
-Task(elsabro-executor) para Plan único
+Task({
+  subagent_type: "elsabro-executor",
+  model: "opus",  // ← OPUS porque escribe código
+  description: "Ejecutar plan único",
+  prompt: "..."
+})
 TaskUpdate({ taskId: "plan-X-id", status: "completed" })
 ```
 
@@ -151,18 +392,53 @@ TaskUpdate({
 })
 ```
 
-### 4.2 Ejecutar verificación en paralelo
+### 4.2 Ejecutar verificación en paralelo (OPUS x3)
+
+**OBLIGATORIO:** Usar 3 agentes OPUS para verificación profunda.
+
 ```javascript
+// Crear task adicional de seguridad
+TaskCreate({
+  subject: "Verify Security & Edge Cases",
+  activeForm: "Verificando seguridad...",
+  metadata: { type: "verifier", area: "security", model: "opus" }
+})  // → verify-security-id
+
+// Actualizar agregador para esperar los 3
+TaskUpdate({
+  taskId: "verify-aggregate-id",
+  addBlockedBy: ["verify-functional-id", "verify-quality-id", "verify-security-id"]
+})
+
+// Marcar todos como in_progress
 TaskUpdate({ taskId: "verify-functional-id", status: "in_progress" })
 TaskUpdate({ taskId: "verify-quality-id", status: "in_progress" })
-
-// Lanzar agentes verificadores en paralelo
-Task(elsabro-verifier): Verifica funcionalidad |
-Task(elsabro-verifier): Verifica calidad
+TaskUpdate({ taskId: "verify-security-id", status: "in_progress" })
+
+// Lanzar 3 agentes OPUS EN PARALELO (UN SOLO MENSAJE)
+Task({
+  subagent_type: "pr-review-toolkit:code-reviewer",
+  model: "opus",  // ← OPUS para análisis profundo
+  description: "Code review completo",
+  prompt: "Revisa los cambios buscando bugs, code smells, mejores prácticas..."
+}) |
+Task({
+  subagent_type: "pr-review-toolkit:silent-failure-hunter",
+  model: "opus",  // ← OPUS para edge cases
+  description: "Buscar errores ocultos",
+  prompt: "Busca errores silenciosos, try/catch que ocultan errores, fallbacks problemáticos..."
+}) |
+Task({
+  subagent_type: "pr-review-toolkit:pr-test-analyzer",
+  model: "opus",  // ← OPUS para análisis de tests
+  description: "Analizar cobertura de tests",
+  prompt: "Verifica que los tests cubren los cambios, busca casos críticos sin test..."
+})
 
 // Marcar completed al terminar
 TaskUpdate({ taskId: "verify-functional-id", status: "completed" })
 TaskUpdate({ taskId: "verify-quality-id", status: "completed" })
+TaskUpdate({ taskId: "verify-security-id", status: "completed" })
 
 // Agregador se desbloquea y genera reporte final
 TaskUpdate({ taskId: "verify-aggregate-id", status: "in_progress" })
@@ -312,74 +588,251 @@ TaskUpdate({
 ```
 </parallel_execution>
 
+<worktrees_integration>
+## Integración con Worktrees Paralelos
+
+**IMPORTAR**: En waves con múltiples agentes, usar worktrees para aislamiento.
+
+### Cuándo Usar Worktrees
+
+- Profile "careful": SIEMPRE usar worktrees
+- Más de 2 agentes en wave: Considerar worktrees
+- Archivos compartidos entre agentes: OBLIGATORIO usar worktrees
+
+### Flujo con Worktrees
+
+```javascript
+// Antes de ejecutar wave paralela
+if (shouldUseWorktrees(wave, profile)) {
+  const agents = wave.plans.map(p => p.agent);
+
+  // Crear worktrees
+  Bash(`./scripts/setup-parallel-worktrees.sh create ${agents.join(' ')}`);
+
+  // Ejecutar agentes en sus worktrees
+  for (const agent of agents) {
+    Task({
+      subagent_type: agent,
+      prompt: `Trabaja en worktree: ../elsabro-worktrees/${agent}-wt/`
+    });
+  }
+
+  // Merge y cleanup al completar
+  Bash(`./scripts/setup-parallel-worktrees.sh complete ${agents.join(' ')}`);
+}
+```
+
+### Resolución de Conflictos
+
+Si hay conflictos en el merge:
+1. Pausar ejecución
+2. Mostrar conflictos al usuario
+3. Opciones: resolver manual, descartar branch, o abortar
+</worktrees_integration>
+
 <error_handling>
-## Manejo de Errores
+## Manejo de Errores en Ejecucion Paralela
+
+**IMPORTAR**: Este comando DEBE seguir `/references/error-contracts.md`.
+
+### Inicializacion con Contratos
+
+```javascript
+// Antes de cualquier wave, inicializar contratos
+const registryValidator = new ContractRegistryValidator();
+const sessionValidator = new ContractSessionValidator();
+const timeoutHandler = new ContractTimeoutHandler();
+const retryPolicy = new ContractRetryPolicy({
+  maxAttempts: 3,
+  baseDelayMs: 1000,
+  backoffMultiplier: 2
+});
+const errorAggregator = new ContractErrorAggregator("quorum");
+const severityClassifier = new ContractSeverityClassifier();
+
+// 1. Validar registry
+const agentsNeeded = dispatcher.exploration.agents;
+const batch = await registryValidator.validateBatch(agentsNeeded);
+if (!batch.canProceed) {
+  return handleCriticalError("REGISTRY_MISSING", batch.details);
+}
+
+// 2. Validar sesion
+const session = await sessionValidator.load();
+if (!session.success) {
+  return handleCriticalError("SESSION_INVALID", session);
+}
+```
+
+### Error Handling por Fase
 
-### Política de Ejecución Paralela
+#### Fase Exploracion (HAIKU x3)
+```javascript
+// Policy: continue_all (exploracion es best-effort)
+errorAggregator.setPolicy("continue_all");
 
-Este comando usa **policy: quorum** por defecto.
+const results = await Promise.all([
+  executeWithRetry("explore-1", () => Task(Explore)),
+  executeWithRetry("explore-2", () => Task(CodeExplorer)),
+  executeWithRetry("explore-3", () => Task(Plan))
+]);
 
+const summary = await errorAggregator.aggregate("exploration", results);
+// continue_all: siempre continua, reporta al final
 ```
-┌────────────────────────────────────────────────┐
-│  PARALLEL EXECUTION POLICY: quorum             │
-├────────────────────────────────────────────────┤
-│  Si >50% de agentes tienen éxito → continuar  │
-│  Si ≤50% de agentes fallan → STOP             │
-└────────────────────────────────────────────────┘
+
+#### Fase Implementacion (OPUS x2 por wave)
+```javascript
+// Policy: quorum (>50% debe tener exito)
+errorAggregator.setPolicy("quorum");
+
+for (const wave of waves) {
+  timeoutHandler.startTimeout(wave.id, 60 * 60 * 1000); // 60min por wave
+
+  const results = await Promise.all(
+    wave.plans.map(plan =>
+      executeWithRetry(plan.id, () => Task(elsabro-executor, plan))
+    )
+  );
+
+  const summary = await errorAggregator.aggregate(wave.id, results);
+
+  if (summary.decision === "STOP") {
+    // Quorum no alcanzado
+    await notifyUserImmediately({
+      severity: "CRITICAL",
+      message: `Wave ${wave.id} fallo: ${summary.reason}`,
+      options: ["retry", "debug", "abort"]
+    });
+    return;
+  }
+
+  timeoutHandler.completeTimeout(wave.id);
+}
 ```
 
-### Clasificación de Errores
+#### Fase Verificacion (OPUS x3)
+```javascript
+// Policy: fail_fast (verificacion debe pasar completa)
+errorAggregator.setPolicy("fail_fast");
+
+const verificationResults = await Promise.all([
+  executeWithRetry("verify-code", () => Task(CodeReviewer)),
+  executeWithRetry("verify-silent", () => Task(SilentFailureHunter)),
+  executeWithRetry("verify-tests", () => Task(TestAnalyzer))
+]);
+
+const summary = await errorAggregator.aggregate("verification", verificationResults);
+
+if (summary.decision === "STOP") {
+  // Cualquier fallo en verificacion es critico
+  await displayVerificationFailure(summary);
+  return;
+}
+```
 
-| Severity | Emoji | Acción |
-|----------|-------|--------|
-| 🔴 CRITICAL | Parar | No puede continuar de ninguna forma |
-| 🟠 HIGH | Preguntar | Ofrecer opciones: fix/skip/abort |
-| 🟡 MEDIUM | Warning | Mostrar y continuar |
-| ⬜ LOW | Info | Log y continuar |
+### Escalamiento de Errores
 
-### Si una tarea falla
+```
+┌─────────────────────────────────────────────────────────────────────┐
+│             ESCALAMIENTO DE ERRORES                                 │
+├─────────────────────────────────────────────────────────────────────┤
+│                                                                     │
+│  Error detectado                                                    │
+│        ↓                                                            │
+│  SeverityClassifier.classify(error)                                 │
+│        ↓                                                            │
+│  ┌─────────────────────────────────────────────────────────────┐   │
+│  │ CRITICAL: Notificar inmediatamente, STOP                    │   │
+│  │ HIGH:     Notificar, ofrecer opciones [fix/skip/abort]      │   │
+│  │ MEDIUM:   Agregar a resumen, continuar                      │   │
+│  │ LOW:      Log para debugging, continuar                     │   │
+│  └─────────────────────────────────────────────────────────────┘   │
+│                                                                     │
+└─────────────────────────────────────────────────────────────────────┘
+```
+
+### Retry Automatico con Backoff
 
+```javascript
+async function executeWithRetry(operationId, operation) {
+  return await retryPolicy.executeWithRetry(
+    operationId,
+    operation,
+    {
+      onAttempt: (attempt) => {
+        console.log(`[RETRY] ${operationId}: Intento ${attempt}/3`);
+      },
+      onSuccess: (result, attempts) => {
+        if (attempts > 1) {
+          console.log(`[RECOVERED] ${operationId}: Exitoso en intento ${attempts}`);
+        }
+      },
+      onFailure: (error, attempts) => {
+        console.error(`[FAILED] ${operationId}: Fallo despues de ${attempts} intentos`);
+
+        // Clasificar para decidir siguiente accion
+        const classification = severityClassifier.classify(error.message);
+        if (classification.severity === "CRITICAL") {
+          throw new CriticalError(error, classification);
+        }
+      }
+    }
+  );
+}
 ```
-1. CLASIFICAR ERROR:
-   - Tests fallan → HIGH
-   - Build falla → HIGH
-   - Dependencia falta → HIGH (auto-fixable)
-   - Lint warnings → MEDIUM
-   - File not found crítico → CRITICAL
 
-2. APLICAR RETRY (si es transitorio):
-   - Attempt 1: Ejecutar
-   - Attempt 2: Esperar 1s, reintentar
-   - Attempt 3: Esperar 2s, reintentar
-   - Máximo 3 intentos, timeout total 2 min
+### Guardar Estado de Errores
 
-3. SI RETRY FALLA → Escalar según severidad
+Al completar cada wave (exito o fallo):
 
-4. MOSTRAR ERROR formateado:
-   ╔══════════════════════════════════════════╗
-   ║  🟠 ERROR: TESTS_FAILED                  ║
-   ║  Severity: HIGH                          ║
-   ╠══════════════════════════════════════════╣
-   ║  [Detalles del error]                    ║
-   ╠══════════════════════════════════════════╣
-   ║  [d] Debug   [s] Skip   [a] Abort        ║
-   ╚══════════════════════════════════════════╝
+```javascript
+// Actualizar state.json con errores para recovery
+state.errors = {
+  count: allErrors.length,
+  lastError: allErrors[allErrors.length - 1],
+  byWave: errorsByWave,
+  bySeverity: {
+    CRITICAL: criticalErrors,
+    HIGH: highErrors,
+    MEDIUM: mediumErrors,
+    LOW: lowErrors
+  }
+};
+
+state.parallelExecution = {
+  policy: currentPolicy,
+  activeAgents: [],
+  completedAgents: completedAgentIds,
+  failedAgents: failedAgentIds
+};
+
+await sessionValidator.save(state);
 ```
 
-### Reglas de Desviación
+### Clasificacion de Errores (Referencia Rapida)
+
+| Severity | Emoji | Accion |
+|----------|-------|--------|
+| CRITICAL | Parar | No puede continuar de ninguna forma |
+| HIGH | Preguntar | Ofrecer opciones: fix/skip/abort |
+| MEDIUM | Warning | Mostrar y continuar |
+| LOW | Info | Log y continuar |
+
+### Reglas de Desviacion
 
-| Situación | Severity | Acción |
+| Situacion | Severity | Accion |
 |-----------|----------|--------|
 | Bug que impide continuar | HIGH | Auto-fix (3 intentos) |
-| Falta validación crítica | HIGH | Auto-add |
+| Falta validacion critica | HIGH | Auto-add |
 | Falta dependencia | HIGH | Auto-install |
-| Cambio arquitectónico | HIGH | CHECKPOINT |
+| Cambio arquitectonico | HIGH | CHECKPOINT |
 | Tests fallan | HIGH | Debug o skip |
 | Lint warnings | MEDIUM | Continuar |
 
 ### Actualizar Estado con Tasks
 
-Después de errores, actualizar tanto SESSION-STATE.json como Tasks:
+Despues de errores, actualizar tanto SESSION-STATE.json como Tasks:
 
 ```javascript
 // 1. Actualizar task con metadata de error
@@ -405,13 +858,13 @@ TaskCreate({
   metadata: { type: "bugfix", parentPlan: "plan-X-id" }
 })  // → bugfix-id
 
-// 3. Bloquear verificación hasta que bugfix complete
+// 3. Bloquear verificacion hasta que bugfix complete
 TaskUpdate({
   taskId: "verify-aggregate-id",
   addBlockedBy: ["bugfix-id"]
 })
 
-// 4. También actualizar SESSION-STATE.json para compatibilidad
+// 4. Tambien actualizar SESSION-STATE.json para compatibilidad
 ```
 
 ### Rollback de Estado con Tasks
@@ -435,7 +888,7 @@ TaskUpdate({ taskId: "plan-X-id", status: "completed" })
 // Listar todas las tasks
 TaskList()
 
-// Ver detalles de una task específica
+// Ver detalles de una task especifica
 TaskGet({ taskId: "plan-X-id" })
 ```
 </error_handling>