@saulwade/swl-ses 1.0.0

package/habilidades/drift-detection/SKILL.md

@@ -0,0 +1,179 @@
+---
+name: drift-detection
+version: 1.0.0
+herramientasPermitidas: [Read]
+description: "Detección de drift de métricas de agentes/skills via ventana deslizante (7d) vs baseline (4 semanas). Integrado al operador Reflect del ciclo AGP."
+exclusiones:
+  - "No cargar para detectar drift en código de aplicación (regressions de negocio); este skill detecta drift en métricas de uso de agentes/skills del sistema SWL."
+  - "No cargar si hay menos de 7 días de trazas en `.planning/traces/`; el baseline de 4 semanas no existirá y los resultados serán estadísticamente inválidos."
+  - "No cargar para observabilidad de la aplicación en producción; usar `monitoring-alertas` para eso."
+  - "No cargar manualmente cuando el ciclo AGP ya ejecuta `ejecutarDriftAutomatico()` en cada SubagentStop — invocarlo dos veces dobla el trabajo sin beneficio."
+author: swl-ses
+evolvable: true
+evolvable_scope: [content, examples]
+domain: ingeniería-de-software
+tags: [agp, observabilidad, drift, métricas, ciclo-agp]
+---
+# drift-detection — Detección de drift para el ciclo AGP
+
+Algoritmo de ventana deslizante que compara métricas recientes (últimos 7 días)
+contra un baseline histórico (4 semanas previas) para detectar degradación de
+skills y agentes antes de que el health score lo refleje.
+
+Adaptado de `runDriftCheck`/`getDriftTimeline` en mission-control-main (MIT).
+
+## Módulo principal
+
+`scripts/lib/drift-detector.js` — zero-deps, Node stdlib únicamente.
+
+## Cuándo se activa
+
+- Manual: desde cualquier script o agente que necesite análisis de degradación.
+- Automático (vía `hooks/auto-evolucion.js`): el hook ejecuta `ejecutarDriftAutomatico()`
+  en cada `SubagentStop` con un throttle de 24 h (configurable con `SWL_DRIFT_THROTTLE_H`).
+  Se evalúan los últimos 5 archivos JSONL de trazas. Opt-out total con `SWL_DRIFT_DISABLED=1`.
+- Automático (vía ciclo AGP): `hooks/lib/reflect-classifier.js` expone
+  `ejecutarDriftReflect(rutaJsonl, nombreAgente)` como punto de extensión alternativo.
+- Las trazas de agentes viven en `.planning/traces/YYYY-MM-DD.jsonl`.
+
+## Exports del módulo
+
+```js
+const { detectarDrift, generarLineaTemporal } = require('./scripts/lib/drift-detector');
+```
+
+### `detectarDrift(opts)`
+
+```js
+detectarDrift({
+  rutaJsonl:           '/ruta/a/traces.jsonl',
+  ventanaDias:         7,       // default
+  baselineSemanasBase: 4,       // default
+  umbralPct:           10,      // warn si |drift| > 10%
+  metricas:            ['tokens_promedio_por_sesion', 'tasa_exito_tool', 'tasa_finalizacion_tarea'],
+  agente:              'backend-python-swl',  // para nudges
+})
+```
+
+**Retorna:**
+
+```json
+{
+  "drifts": [
+    {
+      "metrica": "tokens_promedio_por_sesion",
+      "baseline": 1000,
+      "reciente": 2100,
+      "driftPct": 110.0,
+      "estado": "critico"
+    },
+    {
+      "metrica": "tasa_exito_tool",
+      "baseline": 0.9,
+      "reciente": 0.85,
+      "driftPct": -5.56,
+      "estado": "ok"
+    }
+  ],
+  "timestamp": "2026-04-19T12:00:00.000Z",
+  "estado_global": "critico"
+}
+```
+
+**Estados por métrica:**
+
+| Condición | Estado |
+|-----------|--------|
+| `abs(driftPct) <= umbralPct` | `ok` |
+| `abs(driftPct) > umbralPct` | `warn` |
+| `abs(driftPct) > umbralPct * 2` | `critico` |
+
+**Estado global:** el peor estado entre todas las métricas.
+
+### `generarLineaTemporal(opts)`
+
+```js
+generarLineaTemporal({
+  rutaJsonl: '/ruta/a/traces.jsonl',
+  dias:      30,   // default
+})
+// → [{ fecha: '2026-04-19', tokens: 3200, exitos: 12, fallos: 1 }, ...]
+```
+
+Retorna un array de longitud `dias`, uno por día, para visualización en
+el dashboard o en reportes de salud.
+
+## Estructura de eventos esperada en el JSONL
+
+El módulo es permisivo: extrae métricas de cualquier campo que coincida.
+
+| Métrica | Campos aceptados en el evento |
+|---------|-------------------------------|
+| Tokens | `atributos.tokens_totales`, `tokens`, `total_tokens` |
+| Éxito de tool | `success`, `exito`, `atributos.success` |
+| Finalización de tarea | `estado`, `status`, `atributos.estado` (valores: `OK`, `done`, `completado`) |
+| Timestamp | `timestamp`, `ts`, `inicio`, `created_at` |
+
+Formato nativo de `.planning/traces/YYYY-MM-DD.jsonl`:
+
+```json
+{"traceId":"...","nombre":"agent:backend-python-swl","inicio":"2026-04-19T10:00:00.000Z","estado":"OK","atributos":{"tokens_totales":1500}}
+```
+
+## Integración con el ciclo AGP
+
+El operador Reflect (`hooks/lib/reflect-classifier.js`) expone:
+
+```js
+const { ejecutarDriftReflect } = require('./hooks/lib/reflect-classifier');
+
+const resultado = ejecutarDriftReflect(
+  '.planning/traces/2026-04-19.jsonl',
+  'backend-python-swl'
+);
+// resultado: { drifts, timestamp, estado_global } o null si módulo no disponible
+```
+
+Cuando `estado_global === 'critico'`, el módulo emite automáticamente un nudge
+a `.planning/evolucion/nudges.jsonl`:
+
+```json
+{
+  "timestamp": "2026-04-19T12:00:00.000Z",
+  "tipo": "drift-detectado",
+  "agente_o_skill": "backend-python-swl",
+  "metrica": "tokens_promedio_por_sesion",
+  "drift_pct": 110.0,
+  "estado": "critico"
+}
+```
+
+El agente `auto-evolucion-swl` consume estos nudges para proponer mejoras.
+
+## Cómo interpretar los resultados
+
+- **`ok`**: métricas estables. Sin acción requerida.
+- **`warn`**: degradación moderada. Revisar en el próximo ciclo de evolución.
+- **`critico`**: degradación severa. Invocar `/swl:evolucionar` con el agente
+  identificado. El nudge ya fue emitido — aparecerá en `/swl:salud`.
+
+## Cuándo NO cargar
+
+- Se busca detectar regresiones en el código de la aplicación (tests fallando, performance degradada); para eso usar `monitoring-alertas` o el revisor de código correspondiente.
+- El proyecto tiene menos de 7 días de trazas — el baseline de 4 semanas no puede calcularse y `detectarDrift` retornará resultados sin significado estadístico.
+- El ciclo AGP ya tiene configurado el throttle automático de 24 h; invocar el drift manualmente en el mismo intervalo produce el mismo nudge dos veces sin nuevo valor.
+
+## Gotchas / Errores comunes no obvios
+
+- **Timestamps inválidos en eventos JSONL provocan líneas ignoradas silenciosamente**: el módulo es permisivo con los campos pero si ningún campo de timestamp (`timestamp`, `ts`, `inicio`, `created_at`) tiene una fecha ISO válida, el evento se descarta del cálculo. Causa: eventos generados con timestamps de formato local (ej. `"19/04/2026"`) no pasan la validación. Solución: verificar que todos los eventos JSONL del trace tengan al menos un campo de timestamp en formato ISO 8601 — si el baseline aparece como 0, es el primer síntoma de eventos descartados.
+- **Estado `critico` emitido por baseline con muy pocos eventos**: si el baseline de 4 semanas tiene solo 3 eventos y la ventana de 7 días tiene 8, el `driftPct` de tokens se dispara al 166% cuando en realidad el agente está más activo, no degradado. Causa: el módulo no valida que el baseline tenga suficientes eventos para ser estadísticamente válido. Solución: antes de interpretar un estado `critico`, verificar que el baseline tiene al menos 20 eventos — si no, marcar el resultado como `insufficient-data` en lugar de accionar.
+- **Nudge duplicado en `.planning/evolucion/nudges.jsonl` por falta de deduplicación**: el hook se ejecuta dos veces en el mismo `SubagentStop` (por bug de throttle) y emite el mismo nudge dos veces. Causa: el throttle `SWL_DRIFT_THROTTLE_H` no validó correctamente el timestamp del último run. Solución: el archivo `nudges.jsonl` es append-only — antes de emitir un nudge, verificar si el último evento del mismo `agente_o_skill` y `metrica` tiene un timestamp dentro de la ventana de throttle.
+- **`atomicWriteJSON` usado para escribir en nudges.jsonl**: escribir el archivo completo en lugar de hacer append corrompe el historial de nudges previos. Causa: confusión entre archivos de estado mutable (usan `atomicWriteJSON`) y archivos de eventos de alta frecuencia (usan `fs.appendFileSync`). Solución: `nudges.jsonl` es un JSONL de alta frecuencia — siempre usar `fs.appendFileSync(ruta, JSON.stringify(nudge) + '\n')`, nunca reescribir el archivo completo.
+
+## Referencia cruzada
+
+- Módulo: `scripts/lib/drift-detector.js`
+- Tests: `tests/lib/drift-detector.test.js`
+- Operador Reflect: `hooks/lib/reflect-classifier.js`
+- Ciclo AGP: `.planning/evolucion/nudges.jsonl`
+- Origen (adaptado de): `temp/mission-control-main/src/lib/agent-evals.ts` — MIT

package/habilidades/ejecutar-fase/SKILL.md

@@ -0,0 +1,468 @@
+---
+name: ejecutar-fase
+description: Ejecuta el PLAN.md de una fase con commits atómicos por tarea. Aplica reglas de desviación, maneja checkpoints HITL, soporta TDD opcional, y mantiene ESTADO.md y HOJA-RUTA.md actualizados tras cada tarea completada.
+version: "1.1.0"
+herramientasPermitidas: [Read, Write, Edit, Bash, Glob, Grep]
+exclusiones:
+  - "No cargar si no existe PLAN.md con `estado: aprobado` — ejecutar `planear-fase` primero."
+  - "No cargar para ejecutar tareas ad-hoc sin plan formal; si no hay oleadas ni criterios de verificación, no hay fase que ejecutar."
+  - "No cargar para retomar una sesión pausada en checkpoint `decision` o `human-action` sin resolverlo primero — el agente no debe avanzar pasando por alto una decisión pendiente del usuario."
+  - "No cargar solo para verificar el trabajo ya hecho; en ese caso usar `verificar-trabajo`."
+# Nota: este skill supera el límite estándar de 380 líneas (406 líneas en v1.1.0).
+# Excepción aprobada: las secciones Phase Gates y Dev↔QA Loop formal aportan
+# protocolos de calidad de alto valor que no pueden condensarse sin perder
+# precisión operativa. No eliminar contenido para ajustar al límite.
+evolvable: true  # default para skill estandar
+---
+# Habilidad: Ejecutar Fase de Desarrollo
+
+## Propósito
+
+La ejecución es donde el plan se convierte en código. Esta habilidad convierte
+el PLAN.md en cambios reales, verificables y atómicamente comprometidos, con
+trazabilidad completa entre cada tarea y su commit correspondiente. Evita el
+antipatrón de acumular cambios sin verificar y commitear "todo de golpe".
+
+## Cuándo activar
+
+- Existe un PLAN.md válido en `.planning/`
+- El usuario dice "ejecuta la fase" o "ejecuta el plan"
+- Se retoma una fase interrumpida (ESTADO.md indica progreso parcial)
+
+## Cuándo NO cargar
+
+- No hay PLAN.md o el plan tiene `estado: propuesto` (no aprobado) — ejecutar `planear-fase` y obtener aprobación primero.
+- El objetivo es solo verificar calidad del trabajo ya implementado; usar `verificar-trabajo`.
+- Hay un checkpoint `decision` o `human-action` sin resolver en ESTADO.md — resolver el checkpoint antes de continuar la ejecución.
+- Se quiere ejecutar solo una sub-tarea fuera de la secuencia de oleadas del plan; hacerlo rompe el grafo de dependencias y el estado en ESTADO.md.
+
+## Prerrequisito obligatorio
+
+Leer `.planning/fases/0N-PLAN.md` y `.planning/ESTADO.md` (si existe) antes de
+ejecutar la primera tarea.
+
+---
+
+## Protocolo de ejecución por tarea
+
+### Para cada tarea del plan, en orden de oleadas:
+
+```
+1. Leer la descripción completa de la tarea
+2. Verificar que las dependencias estén marcadas como COMPLETADA en ESTADO.md
+3. Ejecutar la implementación
+4. Ejecutar el criterio de verificación de la tarea
+5. Si pasa: hacer commit atómico + actualizar ESTADO.md
+6. Si falla: aplicar retry con backoff exponencial (ver abajo)
+7. Si agota reintentos: marcar como BLOQUEADA y reportar al usuario
+```
+
+### Protocolo de retry con backoff exponencial
+
+Cuando una tarea falla verificacion:
+
+| Intento | Delay | Accion |
+|---------|-------|--------|
+| 1 (original) | — | Ejecutar normalmente |
+| 2 | 0s | Leer error, diagnosticar, corregir UNA cosa, re-verificar |
+| 3 | 5s | Repensar enfoque, corregir, re-verificar |
+| 4 (final) | 15s | Ultimo intento con enfoque diferente |
+
+Reglas:
+- `maxRetries`: 3 (configurable por tarea en el plan)
+- Si el error es identico en 2 intentos: abortar (loop detectado)
+- Si el error es tipo STOP (Regla 4): no reintentar, reportar
+- Registrar en ESTADO.md: `intentos: N, ultimo_error: "desc"`
+
+## Dev↔QA Loop formal
+
+Cuando el plan incluye tareas de implementación seguidas de tareas de verificación
+(patrón `T-NN impl → T-NN+1 verify`), aplicar el loop formal de calidad:
+
+```
+implementador → tdd-qa-swl → [PASS] → siguiente tarea
+                           ↘ [FAIL] → implementador (intento 2)
+                                    → tdd-qa-swl → [PASS]
+                                               ↘ [FAIL] → implementador (intento 3)
+                                                        → tdd-qa-swl → [PASS]
+                                                                   ↘ [FAIL] → ESCALAR
+```
+
+### Reglas del loop
+
+- **Máximo 3 ciclos** Dev→QA por tarea. En el ciclo 3, el agente implementador
+  DEBE cambiar de enfoque completamente, no hacer el mismo fix.
+- **Loop detectado** (mismo error dos veces seguidas): abortar y escalar a
+  `arquitecto-swl` con el diagnóstico completo.
+- **Criterio de PASS**: todos los niveles de validación (1–4) deben pasar,
+  no solo los tests.
+- **Criterio de FAIL**: cualquier nivel de validación falla o el criterio de
+  aceptación de la tarea no se cumple.
+
+### Cómo registrar en ESTADO.md
+
+```markdown
+| T-05 | Crear endpoint /pagos | EN_PROGRESO | — | Ciclo QA: 2/3 |
+```
+
+### Cuándo escalar (Regla 4 del loop)
+
+Si después de 3 ciclos la tarea sigue fallando:
+
+```
+ALERTA: Loop Dev↔QA agotado — T-[NN]: [nombre de la tarea]
+
+Ciclos intentados: 3
+Último error: [descripción exacta]
+Archivos involucrados: [lista]
+
+Escalando a arquitecto-swl para revisión de enfoque.
+NO hacer más intentos de implementación hasta recibir dirección.
+```
+
+### Niveles de validación estructurada (después de cada tarea)
+
+Ejecutar validaciones en orden ascendente. Si un nivel falla, NO avanzar al siguiente:
+
+| Nivel | Qué valida | Ejemplo de comandos |
+|-------|-----------|-------------------|
+| 1. Sintaxis y estilo | Código compila, linter pasa | `ruff check .`, `npx tsc --noEmit`, `cargo clippy`, `go vet ./...` |
+| 2. Tests unitarios | Lógica de negocio correcta | `pytest -x`, `npm test`, `cargo test`, `go test ./...` |
+| 3. Tests de integración | Componentes conectados | `pytest tests/integration/`, `playwright test`, curl a endpoints |
+| 4. Validación de aceptación | Criterio del plan satisfecho | Criterio de verificación específico de la tarea en PLAN.md |
+
+Reglas:
+- Nivel 1 se ejecuta SIEMPRE, incluso en tareas triviales
+- Nivel 2 se ejecuta si existen tests en el proyecto
+- Nivel 3 se ejecuta si la tarea toca integración entre componentes
+- Nivel 4 se ejecuta siempre (es el criterio de verificación de la tarea)
+- Si la validación falla: corregir inmediatamente. NUNCA acumular estado roto
+
+### Formato de commit atómico
+
+```
+[T-NN] tipo(scope): descripción en imperativo
+
+- Detalle adicional si es necesario
+- Referencia a la tarea del plan
+
+Co-Authored-By: SWL Agent <noreply@swl.dev>
+```
+
+Tipos de commit válidos: `feat`, `fix`, `test`, `refactor`, `docs`, `chore`, `migration`
+
+---
+
+## Modo Pipeline: acumulación de resultados entre tareas
+
+Cuando el PLAN.md tiene **7 o más tareas con dependencias encadenadas**, activar
+el modo pipeline para pasar contexto filtrado entre tareas en lugar del contexto
+completo de la conversación.
+
+### Cómo funciona
+
+Al completar cada tarea, generar un `stepResult` compacto:
+
+```json
+{
+  "step": 3,
+  "agentName": "backend-python-swl",
+  "output": {
+    "filesCreated": ["src/models/user.py", "db/migrations/001_users.sql"],
+    "endpointsAdded": ["POST /users", "GET /users/{id}"],
+    "keyDecisions": ["usé async SQLAlchemy con session factory"]
+  },
+  "status": "completed"
+}
+```
+
+Al delegar la siguiente tarea a un agente, construir el `TaskDelegationContext`
+(schema en `manifiestos/handoff-context.json`) incluyendo **solo los stepResults
+que la tarea siguiente necesita** — no el array completo:
+
+```
+TaskDelegationContext:
+  reason: "task_delegation"
+  parentAgent: "orquestador-swl"
+  transferCount: [incrementar desde handoff previo]
+  taskId: "T-04"
+  taskDescription: "[descripción exacta del PLAN.md — self-contained]"
+  verificationCriteria: "[criterio de verificación del plan]"
+  relevantFiles: ["src/models/user.py:1", "db/migrations/001_users.sql"]
+  previousTaskOutputs:
+    - { taskId: "T-03", output: { endpointsAdded: [...] } }
+```
+
+### Beneficio
+
+Un pipeline de 7 tareas pasa ~60% menos contexto a cada agente especializado
+versus pasar el historial completo de la conversación.
+
+### Límite de transferCount
+
+Si `transferCount >= 10`, reportar al usuario:
+```
+ALERTA: Cadena de delegaciones muy larga (transferCount = N).
+Posible loop de agentes. Revisar el PLAN.md y continuar manualmente.
+```
+
+---
+
+## Reglas de desviación
+
+Una desviación ocurre cuando la implementación difiere del plan. Hay tres tipos:
+
+### Desviación Menor (continuar y registrar)
+- Un nombre de función o archivo difiere del plan
+- Se añade un helper que no estaba planificado pero no cambia el alcance
+- El tiempo real es diferente al estimado
+
+**Acción**: Continuar. Registrar en ESTADO.md bajo `## Desviaciones`.
+
+### Desviación Moderada (notificar y continuar)
+- Se descubre que una tarea requiere subdivisión en el momento de ejecutar
+- Se encuentra código existente que cubre parcialmente la tarea
+- Una dependencia no funciona como se esperaba
+
+**Acción**: Notificar al usuario en el mismo mensaje donde reportas avance.
+Registrar decisión tomada en ESTADO.md.
+
+### Desviación Mayor (STOP — requiere replanificación)
+- La tarea no puede completarse sin cambiar el diseño de otra tarea ya completada
+- Se descubre un requerimiento que invalida 2+ tareas del plan
+- La implementación requeriría romper la compatibilidad con código existente
+
+**Acción**: PARAR. No hacer commit. Reportar al usuario con:
+1. Qué se encontró
+2. Qué tareas están afectadas
+3. Opciones de resolución propuestas
+
+---
+
+## Manejo de tareas HITL
+
+Cuando el plan llega a una tarea marcada `HITL`:
+
+1. Presentar al usuario el resultado del trabajo previo
+2. Describir exactamente qué decisión o revisión se necesita
+3. Esperar confirmación explícita antes de continuar
+4. Registrar la respuesta del usuario en ESTADO.md
+
+Formato de presentación de checkpoint:
+
+```
+CHECKPOINT HITL — T-[NN]: [Nombre]
+
+Estado actual: [descripción de lo implementado hasta aquí]
+
+Se necesita tu revisión/decisión:
+[descripción precisa de qué revisar o decidir]
+
+Opciones (si aplica):
+A) [opción A]
+B) [opción B]
+
+¿Cómo procedo?
+```
+
+---
+
+## TDD opcional (activar si el CONTEXTO.md lo requiere)
+
+Cuando el CONTEXTO.md indica que la fase requiere TDD:
+
+### Ciclo RED → GREEN → REFACTOR por tarea
+
+**RED**: Escribir el test que describe el comportamiento esperado.
+El test DEBE fallar. Verificar que falla por la razón correcta, no por error
+de sintaxis o configuración.
+
+**GREEN**: Escribir la implementación mínima que hace pasar el test.
+"Mínima" significa: no implementar más de lo que el test exige. Resistir la
+tentación de añadir casos no cubiertos por tests.
+
+**REFACTOR**: Limpiar el código sin cambiar el comportamiento.
+El test DEBE seguir pasando después del refactor. Hacer commit solo en este paso.
+
+### Cobertura mínima en modo TDD
+
+- Toda función pública tiene al menos 1 test de camino feliz
+- Toda función con branches tiene tests de cada rama relevante
+- Toda función que puede lanzar excepción tiene test del caso de error
+
+---
+
+## Estado de ejecución serializable con execution-state.js
+
+Para planes multi-agente complejos, usar `hooks/lib/execution-state.js` para
+mantener el estado de ejecución serializable y recuperable entre sesiones:
+
+### API disponible
+
+- `nuevo(dir, { planId, tareas })` → inicializa estado de ejecución
+- `leer(dir)` → lee el estado actual (devuelve `null` si no existe)
+- `iniciarAgente(dir, { agente, tareaId })` → marca agente como activo
+- `completarAgente(dir, { agente, tareaId, resultado })` → registra completación
+- `establecerProximo(dir, { agente, tareaId })` → define el siguiente paso
+- `actualizarContexto(dir, datos)` → actualiza contexto compartido entre agentes
+- `formatearResumen(dir)` → resumen legible del estado actual
+- `limpiar(dir)` → elimina el archivo de estado
+
+### Integración con el protocolo de ejecución
+
+Antes de cada tarea:
+```
+estado = leer(dir)
+iniciarAgente(dir, { agente: "backend-python-swl", tareaId: "T-03" })
+```
+
+Después de cada tarea completada:
+```
+completarAgente(dir, { agente: "backend-python-swl", tareaId: "T-03", resultado: { ... } })
+establecerProximo(dir, { agente: "tdd-qa-swl", tareaId: "T-04" })
+```
+
+### Persistencia
+
+El estado se persiste en `.planning/execution-state.json`. Al retomar una sesión
+interrumpida, `leer()` recupera el estado exacto donde se detuvo.
+
+---
+
+## Actualización de ESTADO.md
+
+Actualizar ESTADO.md después de cada tarea (no al final de la oleada):
+
+```markdown
+# ESTADO.md — Fase [N]: [Nombre]
+**Última actualización**: [fecha y hora]
+
+## Progreso
+- Tareas totales: N
+- Completadas: M
+- Bloqueadas: K
+- Pendientes: N-M-K
+
+## Estado por tarea
+| ID   | Nombre | Estado | Commit | Notas |
+|------|--------|--------|--------|-------|
+| T-01 | [nombre] | COMPLETADA | abc1234 | |
+| T-02 | [nombre] | COMPLETADA | def5678 | |
+| T-03 | [nombre] | EN_PROGRESO | — | |
+| T-04 | [nombre] | PENDIENTE | — | depende T-03 |
+| T-05 | [nombre] | BLOQUEADA | — | [descripción del bloqueo] |
+
+## Desviaciones registradas
+| Tarea | Tipo | Descripción | Resolución |
+|-------|------|-------------|-----------|
+|       |      |             |           |
+
+## Decisiones HITL tomadas
+| Tarea | Pregunta | Respuesta del usuario | Fecha |
+|-------|---------|----------------------|-------|
+|       |         |                      |       |
+
+## Próxima acción
+[Qué se ejecuta a continuación y por qué]
+```
+
+---
+
+## Actualización de HOJA-RUTA.md al completar la fase
+
+Al completar todas las tareas del plan:
+
+1. Marcar la fase como completada en HOJA-RUTA.md
+2. Actualizar la fecha real de completación
+3. Añadir nota de desviaciones si las hubo
+4. Marcar la siguiente fase como "lista para discutir"
+
+---
+
+## Modo Ralph: ejecución autónoma hasta completar
+
+Cuando el usuario dice "ejecuta hasta terminar", "modo autónomo" o "modo Ralph":
+
+1. Ejecutar TODAS las tareas del plan en secuencia de oleadas
+2. Después de cada tarea: ejecutar los 4 niveles de validación
+3. Si una validación falla: corregir y re-validar inmediatamente
+4. Si después de 3 intentos no se resuelve: marcar como BLOQUEADA y continuar con la siguiente tarea que no dependa de ella
+5. Al terminar todas las tareas: ejecutar validación completa del proyecto
+6. Si todo pasa: reportar éxito con resumen de lo completado
+7. Si hay tareas bloqueadas: reportar cuáles y por qué
+
+Reglas del modo Ralph:
+- NUNCA preguntar al usuario durante la ejecución (excepto tareas HITL)
+- Registrar CADA decisión tomada en ESTADO.md bajo `## Decisiones autónomas`
+- Si se detecta loop (mismo error 2 veces): abortar esa tarea, NO el modo
+- Al finalizar, producir resumen: tareas completadas, bloqueadas, decisiones tomadas
+- El modo Ralph NO salta el protocolo de retry ni los niveles de validación
+
+---
+
+## Phase Gates — criterios para cambiar de fase
+
+Un Phase Gate es una verificación formal antes de declarar una fase completa
+y comenzar la siguiente. NO avanzar si algún criterio falla.
+
+### Gate de Implementación → Calidad
+
+Antes de invocar al equipo de calidad (tdd-qa-swl, revisor-codigo-swl):
+
+- [ ] Todas las tareas del plan en estado COMPLETADA o BLOQUEADA documentada
+- [ ] Nivel 1 (linter/tipado) pasa en todo el código nuevo: `ruff`, `tsc --noEmit`, `clippy`
+- [ ] Tests existentes siguen pasando (no hay regresiones)
+- [ ] No hay secrets ni hardcodeos detectados por el hook escaneo-secretos
+
+### Gate de Calidad → Deploy
+
+Antes de invocar deploy o release:
+
+- [ ] Score de revisión de código ≥ 9.0/10 (revisor-codigo-swl)
+- [ ] 0 findings críticos de seguridad (revisor-seguridad-swl)
+- [ ] Cobertura de tests ≥ 80% en código nuevo (tdd-qa-swl)
+- [ ] Validación de accesibilidad si hay cambios de UI (accesibilidad-wcag-swl)
+- [ ] Performance sin regresión: p95 ≤ baseline + 20% (si aplica rendimiento-swl)
+
+### Gate de Deploy → Producción
+
+Antes de declarar la fase completa en producción:
+
+- [ ] Runbook de rollback documentado
+- [ ] Alertas de monitoreo configuradas para la nueva funcionalidad
+- [ ] Feature flag listo si el cambio es de alto riesgo
+- [ ] Release notes actualizadas
+
+### Cómo reportar un Gate fallido
+
+```
+PHASE GATE FALLIDO — Gate: [Calidad → Deploy]
+
+Criterio no cumplido: Score de revisión 7.8/10 (mínimo 9.0)
+Findings pendientes:
+  - [CRITICO] Validación de input en endpoint /usuarios/perfil
+  - [ALTO] N+1 query en listado de facturas
+
+Acción requerida: corregir findings antes de continuar.
+NO proceder con el deploy hasta aprobar este gate.
+```
+
+---
+
+## Gotchas / Errores comunes no obvios
+
+- **Dos agentes escriben al mismo archivo en paralelo**: en modo pipeline con oleadas paralelas, dos agentes distintos reciben tareas que tocan el mismo archivo (ej: `ESTADO.md` o un service compartido). Causa: las tareas no tenían dependencia explícita entre sí pero sí tenían acoplamiento de escritura. Solución: en el plan, si dos tareas modifican el mismo archivo, deben estar en oleadas distintas (secuencial), no paralelas.
+- **Commit acumulado al final de la oleada, no por tarea**: el agente ejecuta 3 tareas y hace un solo commit grande al terminar la oleada. Causa: interpretación laxa del protocolo. Solución: el commit se hace inmediatamente después de pasar la verificación de cada tarea individual — si la sesión se interrumpe, el trabajo de las tareas completadas está protegido.
+- **Loop Dev↔QA silencioso**: el mismo error aparece en el ciclo 2 y el ciclo 3 y el agente sigue intentando el mismo fix. Causa: no se detectó que el error era idéntico. Solución: comparar el mensaje de error exacto entre ciclos — si coincide en 2 intentos consecutivos, declarar loop y escalar a `arquitecto-swl`.
+- **ESTADO.md no actualizado tras una tarea completada**: el agente completa T-03 pero no actualiza ESTADO.md antes de iniciar T-04. Causa: se omitió el paso 5 del protocolo. Solución: la actualización de ESTADO.md es parte del protocolo de cada tarea, no opcional — sin ella el estado de ejecución es inconsistente y la reanudación falla.
+- **`transferCount` no incrementado en delegaciones encadenadas**: el orquestador delega 10 tareas sin incrementar el contador, superando el umbral sin alerta. Causa: se olvida actualizar el campo en el `TaskDelegationContext`. Solución: verificar y actualizar `transferCount` antes de cada delegación de tarea; si supera 10, reportar al usuario antes de continuar.
+
+## Checklist de cierre de fase
+
+- [ ] Todas las tareas en ESTADO.md con estado COMPLETADA o documentadas como BLOQUEADA
+- [ ] Todos los commits hechos y referenciados en ESTADO.md
+- [ ] HOJA-RUTA.md actualizado con la fase completada
+- [ ] Desviaciones documentadas
+- [ ] Decisiones HITL registradas con respuesta del usuario
+- [ ] Tests pasan en el estado final del código
+- [ ] No hay `console.log`, `print()` de debug ni pendientes sin ticket en el código nuevo