@saulwade/swl-ses 2.2.4 → 2.3.0

package/habilidades/extractor-de-aprendizajes/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: extractor-de-aprendizajes
 description: Convertir errores y patrones descubiertos durante la implementación en nuevas habilidades o reglas. Ciclo de mejora continua del sistema SWL.
-version: "1.0.6"
+version: "1.0.7"
 herramientasPermitidas: [Read]
 exclusiones:
   - "No cargar para actualizar el perfil del usuario — las correcciones explícitas del usuario van a `instintos/perfil-usuario.yaml` vía `perfilador-usuario-swl`, no a APRENDIZAJES.md."
@@ -291,13 +291,13 @@ Durante `/swl:aprender`, aplicar estas reglas:
 - **`rating: HIGH` asignado sin verificar criterio de irreversibilidad**: el agente promueve a CLAUDE.md un aprendizaje "MEDIUM" por el entusiasmo del momento. Causa: no se aplicó el criterio de "decisión irreversible o bug crítico". Solución: antes de asignar HIGH, verificar: ¿cambiar esto en el futuro requeriría refactorizar múltiples archivos o migrar datos? Si no, mantener MEDIUM.
 - **Regla incompleta sobre registro de hooks**: una entrada en memoria dice "registrar en modulos.json" pero omite `hooks-config.json`, y en la siguiente iteración se repite el fallo en CI porque ambos manifiestos son obligatorios. Causa: la regla de la lección anterior no cubrió todos los manifiestos afectados. Solución: al documentar una regla sobre registro en manifiestos, listar EXPLÍCITAMENTE cada manifiesto con su responsabilidad distinta (`modulos.json` = qué copiar; `hooks-config.json` = cómo registrar evento). Evidencia: tres incidentes históricos del mismo patrón incompleto (v5.7.1, v5.7.2/3, v5.11.0).
 - **Inventario estimado a mano en vez de regenerar**: el agente cuenta "28 hooks" visualmente y propaga la cifra a 5 archivos (CLAUDE/README/package/plugin/SALUD); al regenerar con `scripts/generar-inventario.js` el número real es 30. Causa: confiar en la observación directa en vez de la fuente de verdad determinista. Solución: antes de modificar cualquier contador en documentación oficial, ejecutar el script de inventario y usar su salida como ground truth.
-- **Sub-agentes (Explore + revisores + agentes de documentación) reportan afirmaciones factuales no verificadas** [CONFIRMADO x6]: aplica a `Explore`, `revisor-codigo-swl`, `revisor-seguridad-swl`, `investigador-swl`, `planificador-swl`, `claude-code-guide`, y en general a cualquier sub-agente que reporte hallazgos sobre código o capacidades de herramientas. **Cuatro modos de falla observados**:
+- **Sub-agentes (Explore + revisores + agentes de documentación) reportan afirmaciones factuales no verificadas** [CONFIRMADO x7]: aplica a `Explore`, `revisor-codigo-swl`, `revisor-seguridad-swl`, `investigador-swl`, `planificador-swl`, `claude-code-guide`, y en general a cualquier sub-agente que reporte hallazgos sobre código o capacidades de herramientas. **Cuatro modos de falla observados**:
 
   **Modo A — papers académicos** (sesión 2026-04-25): sub-agente Explore propuso 50h+ para implementar SPRT + Lyapunov + compositionality theorem del paper Bhardwaj 2026; costo real validado fue ~5h (solo Drift Score + Recovery Catalog). Causa: el Explore evalúa portabilidad técnica sin aplicar filtro de "datos disponibles" ni "infraestructura zero-deps". Evidencia: 3 papers analizados (evolver, Bhardwaj 2026, Zhang et al. 2026) con descarte sistemático ~70-90% del contenido propuesto.
 
   **Modo B — repositorios externos** (sesión 2026-05-02 cosecha-temp/ EMAIA): sub-agente Explore analizando `temp/docetl-main` (UC Berkeley, arXiv:2410.12189) afirmó dos cosas FALSAS verificables contra el código del proyecto destino: (1) "EMAIA ya usa LiteLLM" — verificación contra `pyproject.toml` + `grep -r litellm core/` mostró que EMAIA tiene clientes propios (`OllamaClient`/`NIMClient`/`vLLMClient`) y NO usa LiteLLM en absoluto; (2) recomendó portar Gleaning como patrón nuevo, cuando `core/learning/evaluator_optimizer.py` y `core/llm/quality_judge.py` YA implementan Anthropic Evaluator-Optimizer + LLM-as-judge. El fix real era WIRING (~30 LOC), no porting. Costo "MEDIO" del agente quedó como BAJO real. Causa: el Explore evalúa el repo externo en aislamiento, sin leer paths del proyecto destino para verificar qué mecanismos ya existen.
 
-  **Modo C — revisores reportan ubicaciones y severidades incorrectas en código del proyecto** (sesión 2026-05-12 SIGM): `revisor-codigo-swl` ejecutado en `/swl:verificar --until-converge` reportó dos errores factuales: (1) **ubicación incorrecta**: "deferred import en `caja/router.py:545`" cuando la línea real estaba en `caja/service.py:545` — el archivo `caja/router.py` solo tiene 157 líneas (`wc -l caja/router.py = 157`); (2) **severidad subestimada**: reportó "mismatch `CobroConsolidadoResponse` en pantalla de éxito" como MAYOR, mi auditoría manual descubrió que `CobroConsolidadoRequest` también estaba completamente desalineado (más grave, debería ser CRÍTICO bloqueante) — el revisor solo miró el Response. Causa: el revisor analiza código sin re-verificar el path/línea/extensión reportada cuando produce el reporte; sub-agentes basados en LLM hallucinan números de línea con frecuencia ≥15% en archivos grandes.
+  **Modo C — revisores reportan ubicaciones y severidades incorrectas en código del proyecto** (sesión 2026-05-12 SIGM): `revisor-codigo-swl` ejecutado en `/swl:verificar --until-converge` reportó dos errores factuales: (1) **ubicación incorrecta**: "deferred import en `caja/router.py:545`" cuando la línea real estaba en `caja/service.py:545` — el archivo `caja/router.py` solo tiene 157 líneas (`wc -l caja/router.py = 157`); (2) **severidad subestimada**: reportó "mismatch `CobroConsolidadoResponse` en pantalla de éxito" como MAYOR, mi auditoría manual descubrió que `CobroConsolidadoRequest` también estaba completamente desalineado (más grave, debería ser CRÍTICO bloqueante) — el revisor solo miró el Response. Causa: el revisor analiza código sin re-verificar el path/línea/extensión reportada cuando produce el reporte; sub-agentes basados en LLM hallucinan números de línea con frecuencia ≥15% en archivos grandes. **Instancia adicional (sesión 2026-06-15, norma-studio, x7)**: `revisor-codigo-swl` afirmó "Python 3.14 es pre-release, falta `allow-prereleases` en la config" — FALSO: el entorno corría 3.14.4 estable (verificable con `python --version`). El revisor infirió "pre-release" del número de versión alto sin consultar el runtime real. Subcaso: **claims sobre la versión del entorno/runtime** (Python, Node, una dependencia) se verifican ejecutando el reporte del propio runtime (`python --version`, `node -v`, `pip show X`), nunca infiriendo del número.
 
   **Modo D — agentes de documentación responden por inferencia del contexto local sin consultar la fuente oficial** (sesión 2026-06-11 swl-ses Fase 09; precedente 2026-05-15 con runtimes Cursor/Codex): `claude-code-guide` emitió veredicto categórico "Claude Code NO soporta carga condicional por `paths:` en rules; el frontmatter sería inerte" basándose en que la config local del usuario no usaba ese campo (declinó el WebFetch a docs). Un WebFetch directo a `code.claude.com/docs/en/memory` demostró lo contrario: `paths:` es feature nativa documentada con sintaxis exacta, brace expansion y soporte user-level. Aceptar el veredicto habría descartado un slice completo de la fase. Causa: "ausencia de evidencia en el contexto local" tratada como "evidencia de ausencia en el producto" — mismo patrón del precedente 2026-05-15 ("Cursor no soporta hooks" — falso). Las features recientes nunca aparecen en configs existentes precisamente por ser recientes.
 

package/habilidades/planear-fase/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: planear-fase
 description: Crea el PLAN.md ejecutable para una fase de desarrollo. Descompone la fase en tareas atómicas con dependencias explícitas, las agrupa en oleadas de ejecución paralela cuando es posible, y aplica verificación goal-backward para garantizar que el plan completo satisface los criterios de éxito definidos en CONTEXTO.md.
-version: "1.3.1"
+version: "1.3.2"
 herramientasPermitidas: [Read, Write, Edit, Bash, Glob, Grep]
 exclusiones:
   - "No cargar si no existe CONTEXTO.md para la fase — ejecutar `discutir-fase` primero."
@@ -144,10 +144,24 @@ goal-backward deja de ser pregunta abierta y se vuelve **matriz verificable**:
    planes con REQ huérfanos.
 4. Tareas sin REQ son válidas (infraestructura, refactor habilitante) pero la matriz
    las hace visibles.
+5. **REQ verificable por inspección (config, CI, lint, docs) DEBE llevar la marca
+   literal `(verificación: inspección)` en su criterio del CONTEXTO.** Sin esa
+   marca, `verificar-trazabilidad.js` aplica el método por defecto (`test`) y exige
+   un test con marker `verifica: REQ-NN`; un REQ satisfecho por ruff/CI/prosa pero
+   sin esa anotación se reporta como **huérfano (REQ sin test)** aunque esté
+   genuinamente cubierto. Si detectas un REQ de este tipo sin la marca, agrégala al
+   CONTEXTO (`0N-CONTEXTO.md`) antes de construir la matriz — no inventes un test
+   artificial para satisfacer al verificador.
 
 En CONTEXTOs legacy sin REQ-IDs (fases 01-09): aplicar la pregunta abierta clásica
 ("¿el criterio de éxito queda satisfecho?") — cláusula de gracia, sin matriz.
 
+**Formato de header de tarea — dos puntos, no em-dash.** Cada tarea se escribe
+`### T-NN:` (2-4 `#`, dos puntos tras el ID). `verificar-trazabilidad.js` parsea la
+matriz con `/^#{2,4}\s*T-\d{1,3}\s*:/`; un header `#### T-01 — Foo` (em-dash) deja
+la tarea **invisible** y sus REQ huérfanos sin causa aparente. El verificador emite
+un WARN explicando esto, pero el plan debe nacer con el separador correcto.
+
 ---
 
 ## Estructura del PLAN.md

package/habilidades/proceso-debate-adversarial/SKILL.md

@@ -1,164 +1,191 @@
----
-name: proceso-debate-adversarial
-description: >
-  Protocolo de debate adversarial con jueces ciegos para decisiones técnicas
-  subjetivas: dos autores en frío generan candidatos, un crítico forzosamente
-  adversarial los ataca, un sintetizador produce un híbrido y un panel de jueces
-  ciegos con etiquetas aleatorizadas elige al ganador hasta convergencia.
-  Cargar cuando una decisión de arquitectura, diseño o estrategia no tiene
-  métrica objetiva y el riesgo de sycophancy (auto-aprobarse) es alto; también
-  cuando arquitecto-swl evalúa alternativas o /swl:predecir necesita el
-  protocolo de personas en frío.
-version: "1.0.0"
-herramientasPermitidas: [Read, Agent, Skill]
-exclusiones:
-  - "No cargar para decisiones con métrica objetiva verificable — ahí aplica el loop de autoresearch (Verify numérico), no un debate."
-  - "No cargar para revisión de código post-implementación — eso es revisor-codigo-swl / nemesis-auditor-swl."
-  - "No cargar para decisiones triviales o de preferencia personal sin impacto técnico — el costo de 5+ invocaciones de agente no se justifica."
-evolvable: true
----
-# Debate Adversarial con Jueces Ciegos
-
-Protocolo para decidir entre alternativas técnicas **sin métrica objetiva**
-eliminando los dos sesgos que arruinan las auto-evaluaciones de un LLM:
-**sycophancy** (el agente aprueba lo que él mismo generó) y **position bias**
-(el juez prefiere la opción presentada primero). Patrón adoptado del análisis
-de autoresearch v2.1 (`reason-judge-protocol`), adaptado al ecosistema SWL.
-
-**Principio**: el que genera nunca juzga, el que juzga nunca sabe quién generó.
-
-## Cuándo cargar este skill
-
-- Decisión de arquitectura con 2+ alternativas viables sin benchmark objetivo
-  (ej: event sourcing vs CRUD+audit, monolito modular vs microservicios).
-- `arquitecto-swl` necesita justificar un ADR con alternativas evaluadas de
-  forma no sesgada.
-- `/swl:predecir` requiere el protocolo de aislamiento de personas.
-- Decisión de producto/estrategia donde el usuario pide "dame la mejor opción"
-  y una sola pasada produciría la primera idea plausible, no la mejor.
-
-## Los 5 roles — aislamiento obligatorio (COLD START)
-
-| Rol | Recibe | Produce | Regla dura |
-|-----|--------|---------|------------|
-| **Autor-A** | tarea | candidato A | No ve crítica ni candidato B |
-| **Crítico** | tarea + candidato A | ≥3 debilidades con evidencia + qué haría un candidato superior | NUNCA elogia — rol puramente adversarial |
-| **Autor-B** | tarea + candidato A + crítica | candidato B que resuelve la crítica preservando fortalezas de A | No ve al sintetizador |
-| **Sintetizador** | tarea + A + B | candidato híbrido AB | Fusiona lo mejor de ambos, no promedia |
-| **Panel de jueces** (3 default) | tarea + 3 candidatos con **etiquetas aleatorizadas** (X, Y, Z) | ranking 1°/2°/3° + justificación de un párrafo c/u | "Todos están bien" NO es veredicto válido |
-
-**COLD START**: cada rol se ejecuta como invocación independiente del Agent
-tool **sin contexto compartido de sesión** — recibe SOLO los insumos de su fila.
-Pasar el historial completo a un juez invalida el protocolo (sabría quién
-escribió qué).
-
-**Aleatorización de etiquetas**: antes de invocar a los jueces, mapear
-A/B/AB → X/Y/Z con orden aleatorio distinto por juez. Previene position bias.
-
-## El loop de convergencia
-
-```
-Ronda N:
-  1. Autor-A genera candidato (ronda 1) o presenta al incumbente (ronda N>1)
-  2. Crítico ataca → ≥3 debilidades con evidencia
-  3. Autor-B genera candidato alternativo
-  4. Sintetizador produce híbrido AB
-  5. Panel ciego vota → ganador por mayoría (empate → gana el híbrido)
-  6. ¿Ganador == incumbente? → convergencia++ ; si no → convergencia = 1,
-     el ganador se vuelve incumbente
-```
-
-| Condición | Acción |
-|-----------|--------|
-| Mismo incumbente gana 3 rondas consecutivas | **CONVERGIDO** — terminar |
-| Ronda ≥ max (default 8) | **ACOTADO** — reportar mejor candidato actual |
-| Incumbente cambió >5 veces en las últimas 8 rondas | **OSCILACIÓN** — detener y reportar: la tarea está mal planteada o las alternativas son equivalentes |
-
-Registrar cada ronda con `hooks/lib/loop-telemetry.js` (tipo `debate`,
-columnas `ronda, timestamp, etiqueta_ganadora, veredicto, convergencia,
-descripcion`) para que la trayectoria sea auditable y `/swl:status metricas` la lea.
-
-## Anti-herd check — obligatorio
-
-Si TODOS los jueces coinciden en la primera ronda, el sintetizador DEBE
-producir al menos un contraargumento antes de aceptar el consenso. Unanimidad
-inmediata en un debate de alternativas reales es señal de herd bias, no de
-calidad — las alternativas genuinas siempre tienen tradeoffs defendibles.
-
-## Criterios de juez por dominio
-
-| Dominio | Criterios de evaluación |
-|---------|------------------------|
-| Arquitectura de software | escalabilidad, mantenibilidad, rendimiento, seguridad, simplicidad |
-| Estrategia de producto | encaje de mercado, factibilidad, diferenciación, riesgo, tiempos |
-| Decisión de negocio | ROI, riesgo, alineación, recursos requeridos, reversibilidad |
-| Enfoque de seguridad | cobertura, tasa de falsos positivos, practicidad, cumplimiento |
-| Hipótesis de investigación | testabilidad, novedad, soporte de evidencia, poder explicativo |
-
-El juez evalúa CADA candidato contra TODOS los criterios del dominio y
-produce ranking con justificación — nunca un score suelto sin comparación.
-
-## Personas para análisis predictivo
-
-Cuando el objetivo es **predecir problemas de un cambio propuesto** (no
-elegir entre alternativas), usar el modo personas: 5 expertos analizan EN FRÍO
-el mismo cambio y un sintetizador deduplica y rankea. Definiciones completas,
-preguntas guía y red flags por persona en
-[recursos/personas.md](recursos/personas.md). Set default: Arquitecto de
-Software, Analista de Seguridad, Ingeniero de Rendimiento, Ingeniero de
-Confiabilidad, Abogado del Diablo. Set adversarial (`--adversarial`): El
-Rompedor, El Tramposo, El Escalador, El Novato, El Insider Malicioso.
-
-Ranking de hallazgos del sintetizador:
-`severidad × confianza promedio × número de personas que coinciden`.
-
-## Integración con el ecosistema SWL
-
-| Componente | Uso del protocolo |
-|-----------|-------------------|
-| `arquitecto-swl` | Debate para la sección "Alternativas consideradas" de un ADR |
-| `/swl:predecir` | Modo personas pre-implementación |
-| `/swl:nemesis` | El evaluator puede pedir un debate cuando dos remediaciones compiten |
-| `hooks/lib/loop-telemetry.js` | Registro de rondas + handoff para encadenar |
-| `/swl:status metricas` | Lectura de trayectorias de debates en `.planning/loops/` |
-
-## Cuándo NO cargar
-
-- La decisión tiene métrica objetiva (latencia, cobertura, bundle size) — usar
-  el loop autoresearch con Verify numérico; un debate es más caro y menos
-  preciso que medir.
-- El usuario ya tomó la decisión y está documentada en ADR/vault — aplicar
-  `consultar-vault-primero`, no reabrir con un debate.
-- Hay restricción dura que elimina las alternativas (compliance, presupuesto,
-  stack fijo) — verificar restricciones ANTES de armar el debate.
-
-## Gotchas / Errores comunes no obvios
-
-- **Jueces con contexto contaminado**: invocar a los jueces en la misma
-  conversación donde se generaron los candidatos les revela la autoría por el
-  historial. Causa: usar el contexto principal en vez del Agent tool con
-  prompt acotado. Solución: cada juez es una invocación Agent independiente
-  cuyo prompt contiene SOLO tarea + candidatos etiquetados.
-- **Crítico que "equilibra"**: el crítico señala 3 debilidades pero cierra con
-  "en general es un buen enfoque" — eso re-introduce sycophancy y debilita al
-  Autor-B. Solución: el prompt del crítico prohíbe explícitamente elogios y
-  exige proponer qué haría un candidato superior.
-- **Sintetizador que promedia en vez de fusionar**: produce un candidato
-  "tibio" que toma la mitad de cada uno y pierde la coherencia interna de
-  ambos. Solución: el híbrido debe tener una tesis propia — tomar la
-  arquitectura dominante de uno e injertar mecanismos puntuales del otro.
-- **Convergencia falsa por candidatos idénticos**: si Autor-B produce
-  esencialmente el mismo candidato que A, el panel "converge" en ronda 2 sin
-  exploración real. Solución: el prompt de Autor-B exige divergencia
-  estructural, no cosmética; si la crítica fue débil, regenerar la crítica.
-
-## Anti-patrones
-
-- **Debate de 1 ronda presentado como consenso** — sin convergencia ×3 no hay
-  veredicto, hay una primera impresión cara.
-- **Saltarse la aleatorización de etiquetas** "porque los jueces son
-  imparciales" — el position bias es estadístico, no intencional.
-- **Usar el debate para decisiones ya cerradas** — teatro de proceso que
-  quema tokens para justificar lo decidido.
-- **Panel de 1 juez** — un juez único reintroduce el sesgo individual que el
-  panel existe para diluir; mínimo 3, número impar.
+---
+name: proceso-debate-adversarial
+description: >
+  Protocolo de debate adversarial con jueces ciegos para decisiones técnicas
+  subjetivas: dos autores en frío generan candidatos, un crítico forzosamente
+  adversarial los ataca, un sintetizador produce un híbrido y un panel de jueces
+  ciegos con etiquetas aleatorizadas elige al ganador hasta convergencia.
+  Cargar cuando una decisión de arquitectura, diseño o estrategia no tiene
+  métrica objetiva y el riesgo de sycophancy (auto-aprobarse) es alto; también
+  cuando arquitecto-swl evalúa alternativas o /swl:predecir necesita el
+  protocolo de personas en frío.
+version: "1.1.0"
+herramientasPermitidas: [Read, Agent, Skill]
+exclusiones:
+  - "No cargar para decisiones con métrica objetiva verificable — ahí aplica el loop de autoresearch (Verify numérico), no un debate."
+  - "No cargar para revisión de código post-implementación — eso es revisor-codigo-swl / nemesis-auditor-swl."
+  - "No cargar para decisiones triviales o de preferencia personal sin impacto técnico — el costo de 5+ invocaciones de agente no se justifica."
+evolvable: true
+---
+# Debate Adversarial con Jueces Ciegos
+
+Protocolo para decidir entre alternativas técnicas **sin métrica objetiva**
+eliminando los dos sesgos que arruinan las auto-evaluaciones de un LLM:
+**sycophancy** (el agente aprueba lo que él mismo generó) y **position bias**
+(el juez prefiere la opción presentada primero). Patrón adoptado del análisis
+de autoresearch v2.1 (`reason-judge-protocol`), adaptado al ecosistema SWL.
+
+**Principio**: el que genera nunca juzga, el que juzga nunca sabe quién generó.
+
+## Cuándo cargar este skill
+
+- Decisión de arquitectura con 2+ alternativas viables sin benchmark objetivo
+  (ej: event sourcing vs CRUD+audit, monolito modular vs microservicios).
+- `arquitecto-swl` necesita justificar un ADR con alternativas evaluadas de
+  forma no sesgada.
+- `/swl:predecir` requiere el protocolo de aislamiento de personas.
+- Decisión de producto/estrategia donde el usuario pide "dame la mejor opción"
+  y una sola pasada produciría la primera idea plausible, no la mejor.
+
+## Los 5 roles — aislamiento obligatorio (COLD START)
+
+| Rol | Recibe | Produce | Regla dura |
+|-----|--------|---------|------------|
+| **Autor-A** | tarea | candidato A | No ve crítica ni candidato B |
+| **Crítico** | tarea + candidato A | ≥3 debilidades con evidencia + qué haría un candidato superior | NUNCA elogia — rol puramente adversarial |
+| **Autor-B** | tarea + candidato A + crítica | candidato B que resuelve la crítica preservando fortalezas de A | No ve al sintetizador |
+| **Sintetizador** | tarea + A + B | candidato híbrido AB | Fusiona lo mejor de ambos, no promedia |
+| **Panel de jueces** (3 default) | tarea + 3 candidatos con **etiquetas aleatorizadas** (X, Y, Z) | ranking 1°/2°/3° + justificación de un párrafo c/u | "Todos están bien" NO es veredicto válido |
+
+**COLD START**: cada rol se ejecuta como invocación independiente del Agent
+tool **sin contexto compartido de sesión** — recibe SOLO los insumos de su fila.
+Pasar el historial completo a un juez invalida el protocolo (sabría quién
+escribió qué).
+
+**Aleatorización de etiquetas**: antes de invocar a los jueces, mapear
+A/B/AB → X/Y/Z con orden aleatorio distinto por juez. Previene position bias.
+
+## El loop de convergencia
+
+```
+Ronda N:
+  1. Autor-A genera candidato (ronda 1) o presenta al incumbente (ronda N>1)
+  2. Crítico ataca → ≥3 debilidades con evidencia
+  3. Autor-B genera candidato alternativo
+  4. Sintetizador produce híbrido AB
+  5. Panel ciego vota → ganador por mayoría (empate → gana el híbrido)
+  6. ¿Ganador == incumbente? → convergencia++ ; si no → convergencia = 1,
+     el ganador se vuelve incumbente
+```
+
+| Condición | Acción |
+|-----------|--------|
+| Mismo incumbente gana 3 rondas consecutivas | **CONVERGIDO** — terminar |
+| Ronda ≥ max (default 8) | **ACOTADO** — reportar mejor candidato actual |
+| Incumbente cambió >5 veces en las últimas 8 rondas | **OSCILACIÓN** — detener y reportar: la tarea está mal planteada o las alternativas son equivalentes |
+
+Registrar cada ronda con `hooks/lib/loop-telemetry.js` (tipo `debate`,
+columnas `ronda, timestamp, etiqueta_ganadora, veredicto, convergencia,
+descripcion`) para que la trayectoria sea auditable y `/swl:status metricas` la lea.
+
+## Anti-herd check — obligatorio
+
+Si TODOS los jueces coinciden en la primera ronda, el sintetizador DEBE
+producir al menos un contraargumento antes de aceptar el consenso. Unanimidad
+inmediata en un debate de alternativas reales es señal de herd bias, no de
+calidad — las alternativas genuinas siempre tienen tradeoffs defendibles.
+
+## Voto incompleto ≠ refutado + degradación del fan-out ante rate limit
+
+Cuando el fan-out de personas/jueces se ejecuta en paralelo y la API responde
+con rate limit (429) o un juez no completa su veredicto (timeout, error
+terminal), el hallazgo asociado queda **"sin verificar"**, NUNCA "refutado" ni
+"descartado". Conflar "no se pudo verificar" con "verificado falso" descarta
+silenciosamente hallazgos reales — el modo de falla más caro de un panel
+adversarial.
+
+Reglas:
+
+- Un veredicto que no se emite NO cuenta como voto en contra. El conteo de
+  refutación solo suma jueces que **emitieron** un veredicto de refutación
+  explícito. `votos_refutan / votos_emitidos`, nunca `/ jueces_lanzados`.
+- Un hallazgo cuyos votos no se completaron se marca `estado: sin-verificar`
+  (distinto de `confirmado` y de `refutado`) y se reporta como tal — el usuario
+  decide si re-ejecutar ese subconjunto.
+- Ante rate limit en el fan-out: **escalonar** las invocaciones (lanzar por
+  lotes con espera entre lotes) o **reducir** el número de jueces/personas a un
+  quórum mínimo (≥3) antes de abortar. Degradar el panel con aviso visible es
+  preferible a marcar todo lo no votado como refutado (regla
+  `seguridad-agentes.md § Anti-fallback silencioso`).
+
+Nota de alcance: esto aplica al panel de este skill y a `/swl:predecir`. El
+patrón adversarial-verify del harness de Workflow (built-in de Claude Code) NO
+es editable desde swl-ses; su semántica de votos vive fuera de este repo.
+
+## Criterios de juez por dominio
+
+| Dominio | Criterios de evaluación |
+|---------|------------------------|
+| Arquitectura de software | escalabilidad, mantenibilidad, rendimiento, seguridad, simplicidad |
+| Estrategia de producto | encaje de mercado, factibilidad, diferenciación, riesgo, tiempos |
+| Decisión de negocio | ROI, riesgo, alineación, recursos requeridos, reversibilidad |
+| Enfoque de seguridad | cobertura, tasa de falsos positivos, practicidad, cumplimiento |
+| Hipótesis de investigación | testabilidad, novedad, soporte de evidencia, poder explicativo |
+
+El juez evalúa CADA candidato contra TODOS los criterios del dominio y
+produce ranking con justificación — nunca un score suelto sin comparación.
+
+## Personas para análisis predictivo
+
+Cuando el objetivo es **predecir problemas de un cambio propuesto** (no
+elegir entre alternativas), usar el modo personas: 5 expertos analizan EN FRÍO
+el mismo cambio y un sintetizador deduplica y rankea. Definiciones completas,
+preguntas guía y red flags por persona en
+[recursos/personas.md](recursos/personas.md). Set default: Arquitecto de
+Software, Analista de Seguridad, Ingeniero de Rendimiento, Ingeniero de
+Confiabilidad, Abogado del Diablo. Set adversarial (`--adversarial`): El
+Rompedor, El Tramposo, El Escalador, El Novato, El Insider Malicioso.
+
+Ranking de hallazgos del sintetizador:
+`severidad × confianza promedio × número de personas que coinciden`.
+
+## Integración con el ecosistema SWL
+
+| Componente | Uso del protocolo |
+|-----------|-------------------|
+| `arquitecto-swl` | Debate para la sección "Alternativas consideradas" de un ADR |
+| `/swl:predecir` | Modo personas pre-implementación |
+| `/swl:nemesis` | El evaluator puede pedir un debate cuando dos remediaciones compiten |
+| `hooks/lib/loop-telemetry.js` | Registro de rondas + handoff para encadenar |
+| `/swl:status metricas` | Lectura de trayectorias de debates en `.planning/loops/` |
+
+## Cuándo NO cargar
+
+- La decisión tiene métrica objetiva (latencia, cobertura, bundle size) — usar
+  el loop autoresearch con Verify numérico; un debate es más caro y menos
+  preciso que medir.
+- El usuario ya tomó la decisión y está documentada en ADR/vault — aplicar
+  `consultar-vault-primero`, no reabrir con un debate.
+- Hay restricción dura que elimina las alternativas (compliance, presupuesto,
+  stack fijo) — verificar restricciones ANTES de armar el debate.
+
+## Gotchas / Errores comunes no obvios
+
+- **Jueces con contexto contaminado**: invocar a los jueces en la misma
+  conversación donde se generaron los candidatos les revela la autoría por el
+  historial. Causa: usar el contexto principal en vez del Agent tool con
+  prompt acotado. Solución: cada juez es una invocación Agent independiente
+  cuyo prompt contiene SOLO tarea + candidatos etiquetados.
+- **Crítico que "equilibra"**: el crítico señala 3 debilidades pero cierra con
+  "en general es un buen enfoque" — eso re-introduce sycophancy y debilita al
+  Autor-B. Solución: el prompt del crítico prohíbe explícitamente elogios y
+  exige proponer qué haría un candidato superior.
+- **Sintetizador que promedia en vez de fusionar**: produce un candidato
+  "tibio" que toma la mitad de cada uno y pierde la coherencia interna de
+  ambos. Solución: el híbrido debe tener una tesis propia — tomar la
+  arquitectura dominante de uno e injertar mecanismos puntuales del otro.
+- **Convergencia falsa por candidatos idénticos**: si Autor-B produce
+  esencialmente el mismo candidato que A, el panel "converge" en ronda 2 sin
+  exploración real. Solución: el prompt de Autor-B exige divergencia
+  estructural, no cosmética; si la crítica fue débil, regenerar la crítica.
+
+## Anti-patrones
+
+- **Debate de 1 ronda presentado como consenso** — sin convergencia ×3 no hay
+  veredicto, hay una primera impresión cara.
+- **Saltarse la aleatorización de etiquetas** "porque los jueces son
+  imparciales" — el position bias es estadístico, no intencional.
+- **Usar el debate para decisiones ya cerradas** — teatro de proceso que
+  quema tokens para justificar lo decidido.
+- **Panel de 1 juez** — un juez único reintroduce el sesgo individual que el
+  panel existe para diluir; mínimo 3, número impar.

package/habilidades/tdd-workflow/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: tdd-workflow
 description: Flujo completo de Test-Driven Development. Ciclo RED (el test falla) → GREEN (implementación mínima) → REFACTOR (limpieza). Incluye cobertura mínima obligatoria, tests de frontera, factories, fixtures y estrategias para diferentes tipos de código (APIs, services, componentes Angular).
-version: "1.2.1"
+version: "1.2.2"
 herramientasPermitidas: [Read, Bash]
 evolvable: true  # default para skill estandar
 exclusiones:
@@ -536,6 +536,38 @@ archivo creaba el flag, sin ejecutar ninguna assertion. Fix: env var
 
 ---
 
+## Tests E2E de UI con Playwright — gotchas de actionability
+
+Dos fallos recurrentes al automatizar UIs con Playwright donde el test "debería
+pasar" pero hace timeout o no observa el efecto esperado:
+
+- **`fill()` hace timeout en un input que el motor considera "not editable" aunque
+  sea interactivo para el usuario** (widgets custom: input dentro de un overlay/
+  option marcado `[disabled]`, combos con buscador, etc.). Playwright aplica
+  checks de actionability (visible, enabled, editable) y se niega a escribir.
+  Fix: setear el valor con el **setter nativo** y despachar el evento `input` vía
+  `evaluate`, en vez de `fill()`:
+
+  ```js
+  await page.locator('#busqueda').evaluate((el, v) => {
+    const setter = Object.getOwnPropertyDescriptor(
+      window.HTMLInputElement.prototype, 'value').set;
+    setter.call(el, v);
+    el.dispatchEvent(new Event('input', { bubbles: true }));
+  }, 'texto');
+  ```
+
+- **Un click en «Guardar»/«Enviar» que no dispara su request** suele tener un
+  **paso de confirmación intermedio** (diálogo «¿Confirmar?», modal con timeout),
+  no un bug del submit. Antes de concluir "no persiste": verificar en la pestaña
+  de red si hubo (o no) la petición, y buscar un diálogo de confirmación que el
+  test deba cerrar dentro de su timeout. Un submit que pasa por confirmación
+  necesita el click de confirmación en la aserción, no solo el del botón inicial.
+
+Regla general: ante un test E2E que falla, distinguir **bug del producto** de
+**gap del test** verificando el estado real (red, DOM, BD) antes de declarar el
+veredicto — un timeout de actionability casi nunca es un bug de la app.
+
 ## Tests E2E de CLIs interactivos sin PTY real
 
 ### El problema

package/hooks/captura-acciones-post.js

@@ -0,0 +1,151 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: captura-acciones-post.js
+ * Tipo: PostToolUse (todas las herramientas)
+ *
+ * Pobla el estado que el hook SessionStart (`captura-acciones-session.js`)
+ * consumirá para detectar señales de acción del usuario (Fase 17):
+ *   - `git commit` del agente → registra el SHA en agent-commits.jsonl
+ *     (base para detectar revert/reset; sin co-author, regla git-coauthor.md).
+ *   - `Write`/`Edit`/`MultiEdit` → registra el hash del archivo en
+ *     agent-writes-index.json (base para detectar edición neta del usuario).
+ *   - `Read` de un archivo que el agente escribió cuyo contenido en disco
+ *     difiere → encola `edicion-manual` en caliente (REQ-17-03).
+ *
+ * Zero-deps salvo la lib `captura-acciones`. Opt-out unificado
+ * SWL_CAPTURAR_FEEDBACK=0. Exit 0 SIEMPRE; nunca bloquea ni muestra al modelo.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+// Require con fallback dual: el instalador aplana `hooks/lib/X.js → <hooks>/X.js`.
+// (Idioma compartido con session-briefing.js/propose-step.js; no se extrae a lib
+// porque cargar esa lib requeriría a su vez el mismo fallback — paradoja de
+// bootstrap del aplanado.)
+function requireDual(nombre) {
+  try {
+    return require(`./lib/${nombre}`);
+  } catch (e1) {
+    if (e1 && e1.code !== 'MODULE_NOT_FOUND') throw e1;
+    return require(`./${nombre}`);
+  }
+}
+
+let lib;
+try {
+  lib = requireDual('captura-acciones');
+} catch (_) {
+  lib = null;
+}
+
+// Preview crudo amplio: se pasa a encolarAccion para que la sanitización corra
+// sobre el texto íntegro (un bloque PEM cabe) ANTES del truncado final a
+// MAX_EVIDENCIA_LEN. Pre-truncar aquí derrotaría el patrón PEM (sec BAJA-2).
+const PREVIEW_RAW = 4096;
+
+/**
+ * Convierte una ruta (abs o rel) a relativa POSIX respecto a baseDir; null si
+ * escapa. Guard léxico (path.relative): rechaza `..` y rutas absolutas. NO
+ * resuelve symlinks — la defensa real es la sanitización + el confinamiento por
+ * índice + que el contenido se trata como dato (nunca se ejecuta); aceptable
+ * para tooling de dev donde el usuario es dueño del repo (sec BAJA-3).
+ */
+function relPosix(baseDir, filePath) {
+  if (!filePath) return null;
+  const abs = path.isAbsolute(filePath) ? filePath : path.resolve(baseDir, filePath);
+  const rel = path.relative(baseDir, abs);
+  if (!rel || rel.startsWith('..') || path.isAbsolute(rel)) return null;
+  return rel.split(path.sep).join('/');
+}
+
+function _leer(baseDir, rel) {
+  try {
+    return fs.readFileSync(path.resolve(baseDir, rel), 'utf8');
+  } catch (_) {
+    return null;
+  }
+}
+
+/** (a) git commit del agente → registrar SHA. */
+function _manejarCommit(input, sessionId, baseDir) {
+  if (typeof input.command !== 'string' || !/\bgit\s+commit\b/.test(input.command)) return;
+  let sha = '';
+  try {
+    sha = execFileSync('git', ['rev-parse', 'HEAD'], { cwd: baseDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'] }).trim();
+  } catch (_) {
+    sha = '';
+  }
+  if (sha) lib.registrarCommitAgente(baseDir, { sessionId, sha });
+}
+
+/** (b) Write/Edit/MultiEdit → registrar hash del archivo tras la escritura. */
+function _manejarEscritura(input, sessionId, baseDir) {
+  const rel = relPosix(baseDir, input.file_path);
+  if (!rel) return;
+  const contenido = _leer(baseDir, rel);
+  if (contenido === null) return;
+  lib.registrarEscrituraAgente(baseDir, rel, contenido, { sessionId });
+}
+
+/** (c) Read de archivo escrito por el agente cuyo contenido difiere → edición manual. */
+function _manejarLectura(input, sessionId, baseDir) {
+  const rel = relPosix(baseDir, input.file_path);
+  if (!rel) return;
+  const indice = lib.leerIndiceWrites(baseDir);
+  if (!indice[rel]) return;
+  const contenido = _leer(baseDir, rel);
+  if (contenido === null) return;
+  if (lib.detectarEdicionManual(rel, contenido, indice)) {
+    lib.encolarAccion(baseDir, {
+      accion: 'edicion-manual',
+      archivo: rel,
+      evidencia: contenido.slice(0, PREVIEW_RAW),
+      sessionId,
+    });
+  }
+}
+
+/**
+ * Procesa un evento PostToolUse. Orquesta los 3 handlers según la herramienta.
+ * @param {object} data    payload del hook (tool_name, tool_input, session_id...)
+ * @param {string} baseDir raíz del proyecto.
+ */
+function procesarTurno(data, baseDir) {
+  if (process.env.SWL_CAPTURAR_FEEDBACK === '0') return;
+  if (!lib || !data) return;
+  const toolName = String(data.tool_name || data.tool?.name || '');
+  if (!toolName) return;
+  const sessionId = String(data.session_id || 'default');
+  const input = data.tool_input || data.tool?.input || {};
+  try {
+    if (toolName === 'Bash') {
+      _manejarCommit(input, sessionId, baseDir);
+    } else if (toolName === 'Write' || toolName === 'Edit' || toolName === 'MultiEdit') {
+      if (input.file_path) _manejarEscritura(input, sessionId, baseDir);
+    } else if (toolName === 'Read') {
+      if (input.file_path) _manejarLectura(input, sessionId, baseDir);
+    }
+  } catch (_) {
+    /* nunca bloquear */
+  }
+}
+
+// Listeners de stdin SOLO en modo CLI (evita colgar la suite de tests).
+if (require.main === module) {
+  let inputRaw = '';
+  process.stdin.on('data', (c) => { inputRaw += c; });
+  process.stdin.on('end', () => {
+    try {
+      const data = JSON.parse(inputRaw);
+      procesarTurno(data, process.cwd());
+    } catch (_) {
+      /* silencioso */
+    }
+  });
+} else {
+  module.exports = { procesarTurno, relPosix };
+}