@saulwade/swl-ses 1.5.2 → 1.6.1

package/habilidades/meta-skills-estandar/recursos/skills-as-agents.md

@@ -1,163 +1,163 @@
-# Skills as Agents — patrón técnico avanzado
-
-Documenta el patrón Anthropic nativo de ejecutar un skill SWL en su propio
-sub-agente con `agent: true` + `model:` en el frontmatter. Origen: artículo
-"Claude Code's Limits Are Generous. The Problem Is Your Harness." sección 2.3.
-
-## Concepto
-
-Un SKILL.md normal es contenido que se carga al contexto del padre cuando
-se invoca con `Skill("nombre")`. El skill aporta reglas, conocimiento o
-guía al modelo del padre, que las usa al razonar.
-
-Con el patrón skills as agents, el skill se vuelve **invocable como
-sub-agente independiente**: tiene su propio modelo, su propio contexto,
-y solo devuelve un resultado acotado al padre. Útil cuando el skill
-procesa un input grande y debe entregar un resumen.
-
-## Cuándo usar este patrón
-
-- El skill procesa un archivo o input grande y debe devolver solo un
-  resumen al padre (ejemplo: extraer TLDR de un PDF de 50 páginas, sin
-  que el texto completo entre al contexto del padre).
-- El skill ejecuta búsqueda exhaustiva o crawling de un codebase completo
-  y el resultado es un set acotado de findings.
-- El skill necesita un modelo distinto al del padre por costo o latencia
-  (Haiku para trabajo mecánico cuando el padre es Opus).
-- El trabajo del skill es paralelizable y se va a invocar varias veces en
-  la misma sesión.
-
-## Cuándo NO usar
-
-- El skill solo aporta reglas o conocimiento estático que se aplica al
-  razonamiento del padre — esos son skills "passive" normales y NO
-  necesitan `agent: true`. Su valor es justamente que cargan reglas al
-  contexto del padre.
-- El skill es referenciado dentro de otro skill como contenido de apoyo
-  — el contexto del padre lo necesita ver.
-- El skill requiere acceso al contexto activo del padre (decisiones
-  tomadas mid-session, archivos ya leídos) — `agent: true` aísla del
-  padre, así que el sub-agente no vería esa información.
-- El skill es invocado una sola vez en la sesión y su output es pequeño
-  — el overhead de spawn de sub-agente puede dominar.
-
-## Ejemplo de skill como agent
-
-```yaml
----
-name: tldr-pdf
-description: >
-  Extrae TLDR de 200 palabras de un PDF sin cargar el texto completo en
-  el contexto del padre. Cargar cuando se reciba ruta a un PDF que solo
-  necesita resumen ejecutivo.
-agent: true
-model: claude-haiku-4-5-20251001
-herramientasPermitidas: [Bash, Read]
----
-
-# tldr-pdf
-
-Recibes la ruta de un PDF como input.
-
-1. Ejecuta `pdftotext "$1" -` para extraer texto.
-2. Lee la salida.
-3. Devuelve SOLO:
-   - 5 bullets de TLDR
-   - 3 quotes que valga la pena conservar
-   - URLs citadas
-
-Nunca devuelvas el texto completo. Nunca expandas más allá de la estructura.
-```
-
-Flujo: el padre invoca `Skill("tldr-pdf")` con la ruta del PDF; el
-sub-agente Haiku ejecuta `pdftotext`, lee la salida (que llena su propio
-contexto, no el del padre), y devuelve ~200 palabras estructuradas. El PDF
-completo nunca toca el contexto del padre.
-
-## Reglas del patrón
-
-### Frontmatter
-
-- `agent: true` activa el modo sub-agente.
-- `model:` debe ser un modelo Anthropic válido. Para skills mecánicos,
-  preferir Haiku (5× más barato que Sonnet, 25× más barato que Opus 4.7).
-- El frontmatter sigue siendo válido SWL: incluir `name`, `description`,
-  `herramientasPermitidas`, `exclusiones` y demás campos obligatorios.
-
-### Cuerpo
-
-- Debe ser **autocontenido**: el sub-agente NO tiene acceso al contexto
-  del padre (CLAUDE.md del proyecto, instintos cargados, sesión activa,
-  archivos previamente leídos). Todo lo que necesite saber tiene que
-  estar en el cuerpo del skill o en lo que reciba como input.
-- El output debe ser **acotado**: si el sub-agente devuelve un dump
-  masivo, se pierde el beneficio (terminamos pasando lo mismo al padre,
-  solo con un round-trip extra). Especificar formato exacto en el
-  cuerpo del skill: número de bullets, longitud máxima, qué incluir y
-  qué no.
-
-### Errores comunes a evitar
-
-- **Usar Opus en `model:` para skills mecánicos**: invalida el ahorro de
-  costo. La mayoría de skills as agents deberían ser Haiku o Sonnet.
-- **Devolver el texto crudo del input**: si el skill recibe un PDF y
-  devuelve el texto completo, no estamos aislando nada. Devuelve siempre
-  la transformación, no el material crudo.
-- **Asumir que el skill verá el CLAUDE.md del proyecto**: no lo verá.
-  Si el skill necesita seguir convenciones del proyecto, hay que
-  explicárselas en el cuerpo.
-
-## Skills SWL candidatos al patrón (no migración masiva)
-
-Evaluación caso por caso. NO aplicar masivamente — el patrón aporta solo
-cuando el skill consume input grande y devuelve output acotado.
-
-| Skill SWL | Por qué encaja | Modelo recomendado |
-|-----------|----------------|--------------------|
-| `extraccion-documentos` | Procesa PDFs/Office grandes | Haiku |
-| `mapear-codebase` | Procesa codebase entero, devuelve reporte | Sonnet |
-| `wiki-conocimiento` (modo query) | Búsqueda en wiki con respuesta acotada | Sonnet |
-
-Skills NO candidatos (son passive, su valor es cargar reglas al contexto del padre):
-
-- `manejo-errores`, `auth-patrones`, `api-rest-diseno`, `accesibilidad-a11y`, etc.
-- Toda regla de estilo o convención por lenguaje.
-- Toda regla SWL en `reglas/`.
-
-## Implicaciones operativas
-
-### Costo
-
-Spawn de sub-agente tiene overhead (system prompt + carga del skill +
-contexto inicial). Para inputs chicos, el overhead supera el ahorro.
-Regla práctica: usar el patrón si el input que el skill procesa es
-≥3,000 tokens (o ≥10K caracteres).
-
-### Latencia
-
-El padre espera al sub-agente antes de continuar. Si el skill demora >10s,
-considerar si la operación cabe en el padre directamente (sin spawn).
-
-### Trazabilidad
-
-Los sub-agentes spawneados aparecen en `claude-usage` (vendor SWL) como
-invocaciones separadas con su propio modelo. Útil para entender qué
-porcentaje del costo viene de sub-agentes vs. trabajo del padre.
-
-### Compatibilidad con SWL
-
-- El skill sigue registrado normalmente en `manifiestos/modulos.json`.
-- El skill se invoca igual: `Skill("nombre")`. La diferencia es interna
-  (el harness Anthropic decide si lo carga al padre o lo ejecuta como
-  sub-agente según el frontmatter).
-- Hooks SWL siguen aplicando: `linea-estado.js`, `monitor-contexto.js`,
-  `audit-trail.js` registran las invocaciones del sub-agente.
-
-## Referencias
-
-- Artículo de origen: "Claude Code's Limits Are Generous. The Problem Is
-  Your Harness." (sección 2.3 — Skills Can Also Be Invoked as Agents).
-- Documentación oficial Anthropic sobre Claude Skills (cuando esté
-  disponible).
-- `Skill("harness-claude-code")` — uso operativo del patrón en sesiones
-  largas, junto con sub-agentes via Task tool y delegación explícita.
+# Skills as Agents — patrón técnico avanzado
+
+Documenta el patrón Anthropic nativo de ejecutar un skill SWL en su propio
+sub-agente con `agent: true` + `model:` en el frontmatter. Origen: artículo
+"Claude Code's Limits Are Generous. The Problem Is Your Harness." sección 2.3.
+
+## Concepto
+
+Un SKILL.md normal es contenido que se carga al contexto del padre cuando
+se invoca con `Skill("nombre")`. El skill aporta reglas, conocimiento o
+guía al modelo del padre, que las usa al razonar.
+
+Con el patrón skills as agents, el skill se vuelve **invocable como
+sub-agente independiente**: tiene su propio modelo, su propio contexto,
+y solo devuelve un resultado acotado al padre. Útil cuando el skill
+procesa un input grande y debe entregar un resumen.
+
+## Cuándo usar este patrón
+
+- El skill procesa un archivo o input grande y debe devolver solo un
+  resumen al padre (ejemplo: extraer TLDR de un PDF de 50 páginas, sin
+  que el texto completo entre al contexto del padre).
+- El skill ejecuta búsqueda exhaustiva o crawling de un codebase completo
+  y el resultado es un set acotado de findings.
+- El skill necesita un modelo distinto al del padre por costo o latencia
+  (Haiku para trabajo mecánico cuando el padre es Opus).
+- El trabajo del skill es paralelizable y se va a invocar varias veces en
+  la misma sesión.
+
+## Cuándo NO usar
+
+- El skill solo aporta reglas o conocimiento estático que se aplica al
+  razonamiento del padre — esos son skills "passive" normales y NO
+  necesitan `agent: true`. Su valor es justamente que cargan reglas al
+  contexto del padre.
+- El skill es referenciado dentro de otro skill como contenido de apoyo
+  — el contexto del padre lo necesita ver.
+- El skill requiere acceso al contexto activo del padre (decisiones
+  tomadas mid-session, archivos ya leídos) — `agent: true` aísla del
+  padre, así que el sub-agente no vería esa información.
+- El skill es invocado una sola vez en la sesión y su output es pequeño
+  — el overhead de spawn de sub-agente puede dominar.
+
+## Ejemplo de skill como agent
+
+```yaml
+---
+name: tldr-pdf
+description: >
+  Extrae TLDR de 200 palabras de un PDF sin cargar el texto completo en
+  el contexto del padre. Cargar cuando se reciba ruta a un PDF que solo
+  necesita resumen ejecutivo.
+agent: true
+model: claude-haiku-4-5-20251001
+herramientasPermitidas: [Bash, Read]
+---
+
+# tldr-pdf
+
+Recibes la ruta de un PDF como input.
+
+1. Ejecuta `pdftotext "$1" -` para extraer texto.
+2. Lee la salida.
+3. Devuelve SOLO:
+   - 5 bullets de TLDR
+   - 3 quotes que valga la pena conservar
+   - URLs citadas
+
+Nunca devuelvas el texto completo. Nunca expandas más allá de la estructura.
+```
+
+Flujo: el padre invoca `Skill("swl-markitdown")` con la ruta del PDF; el
+sub-agente Haiku ejecuta `pdftotext`, lee la salida (que llena su propio
+contexto, no el del padre), y devuelve ~200 palabras estructuradas. El PDF
+completo nunca toca el contexto del padre.
+
+## Reglas del patrón
+
+### Frontmatter
+
+- `agent: true` activa el modo sub-agente.
+- `model:` debe ser un modelo Anthropic válido. Para skills mecánicos,
+  preferir Haiku (5× más barato que Sonnet, 25× más barato que Opus 4.7).
+- El frontmatter sigue siendo válido SWL: incluir `name`, `description`,
+  `herramientasPermitidas`, `exclusiones` y demás campos obligatorios.
+
+### Cuerpo
+
+- Debe ser **autocontenido**: el sub-agente NO tiene acceso al contexto
+  del padre (CLAUDE.md del proyecto, instintos cargados, sesión activa,
+  archivos previamente leídos). Todo lo que necesite saber tiene que
+  estar en el cuerpo del skill o en lo que reciba como input.
+- El output debe ser **acotado**: si el sub-agente devuelve un dump
+  masivo, se pierde el beneficio (terminamos pasando lo mismo al padre,
+  solo con un round-trip extra). Especificar formato exacto en el
+  cuerpo del skill: número de bullets, longitud máxima, qué incluir y
+  qué no.
+
+### Errores comunes a evitar
+
+- **Usar Opus en `model:` para skills mecánicos**: invalida el ahorro de
+  costo. La mayoría de skills as agents deberían ser Haiku o Sonnet.
+- **Devolver el texto crudo del input**: si el skill recibe un PDF y
+  devuelve el texto completo, no estamos aislando nada. Devuelve siempre
+  la transformación, no el material crudo.
+- **Asumir que el skill verá el CLAUDE.md del proyecto**: no lo verá.
+  Si el skill necesita seguir convenciones del proyecto, hay que
+  explicárselas en el cuerpo.
+
+## Skills SWL candidatos al patrón (no migración masiva)
+
+Evaluación caso por caso. NO aplicar masivamente — el patrón aporta solo
+cuando el skill consume input grande y devuelve output acotado.
+
+| Skill SWL | Por qué encaja | Modelo recomendado |
+|-----------|----------------|--------------------|
+| `extraccion-documentos` | Procesa PDFs/Office grandes | Haiku |
+| `mapear-codebase` | Procesa codebase entero, devuelve reporte | Sonnet |
+| `wiki-conocimiento` (modo query) | Búsqueda en wiki con respuesta acotada | Sonnet |
+
+Skills NO candidatos (son passive, su valor es cargar reglas al contexto del padre):
+
+- `manejo-errores`, `auth-patrones`, `api-rest-diseno`, `accesibilidad-a11y`, etc.
+- Toda regla de estilo o convención por lenguaje.
+- Toda regla SWL en `reglas/`.
+
+## Implicaciones operativas
+
+### Costo
+
+Spawn de sub-agente tiene overhead (system prompt + carga del skill +
+contexto inicial). Para inputs chicos, el overhead supera el ahorro.
+Regla práctica: usar el patrón si el input que el skill procesa es
+≥3,000 tokens (o ≥10K caracteres).
+
+### Latencia
+
+El padre espera al sub-agente antes de continuar. Si el skill demora >10s,
+considerar si la operación cabe en el padre directamente (sin spawn).
+
+### Trazabilidad
+
+Los sub-agentes spawneados aparecen en `claude-usage` (vendor SWL) como
+invocaciones separadas con su propio modelo. Útil para entender qué
+porcentaje del costo viene de sub-agentes vs. trabajo del padre.
+
+### Compatibilidad con SWL
+
+- El skill sigue registrado normalmente en `manifiestos/modulos.json`.
+- El skill se invoca igual: `Skill("nombre")`. La diferencia es interna
+  (el harness Anthropic decide si lo carga al padre o lo ejecuta como
+  sub-agente según el frontmatter).
+- Hooks SWL siguen aplicando: `linea-estado.js`, `monitor-contexto.js`,
+  `audit-trail.js` registran las invocaciones del sub-agente.
+
+## Referencias
+
+- Artículo de origen: "Claude Code's Limits Are Generous. The Problem Is
+  Your Harness." (sección 2.3 — Skills Can Also Be Invoked as Agents).
+- Documentación oficial Anthropic sobre Claude Skills (cuando esté
+  disponible).
+- `Skill("harness-claude-code")` — uso operativo del patrón en sesiones
+  largas, junto con sub-agentes via Task tool y delegación explícita.

package/habilidades/nemesis-evaluacion-json/SKILL.md

@@ -9,6 +9,11 @@ description: >
   alimentar el ciclo de remediación de /swl:nemesis --remediar, o cuando
   un componente downstream necesita parsear el veredicto de una auditoría
   nemesis.
+version: "1.0.0"
+exclusiones:
+  - "No cargar para schemas de otros tipos de auditoría (revisor-codigo, revisor-seguridad) — cada uno tiene su propio formato."
+  - "No cargar fuera del contexto del agente nemesis-auditor-swl o del comando /swl:nemesis — el schema es específico de esta auditoría."
+  - "No cargar para definir nuevos formatos de evaluación — este skill describe el formato existente, no especifica formatos nuevos."
 ---
 
 # Schema del evaluacion.json del Nemesis

package/habilidades/nemesis-redistribuir/SKILL.md

@@ -9,6 +9,11 @@ description: >
   /swl:nemesis cuando la fase 0 detecta scope grande, antes de invocar al
   agente nemesis-auditor-swl. NO cargar para scope pequeño — el bucle iterativo
   Feynman+State del agente es más profundo que la redistribución.
+version: "1.0.0"
+exclusiones:
+  - "No cargar para scope <1500 LOC ni <5 archivos — el agente Nemesis directo es suficiente."
+  - "No cargar fuera del flujo /swl:nemesis — la redistribución es específica de ese comando."
+  - "No cargar para revisiones de otros tipos (revisor-codigo, revisor-seguridad) — esos no requieren redistribución por scope."
 ---
 
 # Redistribución de scope para Nemesis

package/habilidades/node-experto/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: node-experto
 description: Node.js y TypeScript backend moderno. Cubre patterns de Express/Fastify/NestJS, error handling middleware, streams y buffers, worker threads y clustering, Prisma/Drizzle ORM, validación con Zod, graceful shutdown y anti-patrones críticos como callback hell y event loop blocking.
-version: "1.0.2"
+version: "1.1.0"
 evolved: true
-evolved-from: "1.0.1"
+evolved-from: "1.0.2"
 evolved-at: "2026-05-16"
 evolved-by: "aprender"
-evolved-note: "v1.0.1: gotcha req.destroy() + CRLF + TOML literal. v1.0.2: gotchas `undefined<N` (NaN comparison), first-wins vs deep merge en config (PR #27 #30 v1.5.2), `assert.notMatch` no existe."
+evolved-note: "v1.1.0 (MINOR): sección completa nueva 'Patrones de readline + prompts asíncronos' — Promise+close obligatorio, pausa de spinners durante prompts, listener leak prevention. Origen: H1 sesión 2026-05-16 (race condition spinner/prompt en swl-ses update + premature close detectado por Cursor IDE + /swl:nemesis --remediar iter-2 con 2 fixes adicionales). v1.0.2: gotchas `undefined<N` (NaN comparison), first-wins vs deep merge en config (PR #27 #30 v1.5.2), `assert.notMatch` no existe. v1.0.1: gotcha req.destroy() + CRLF + TOML literal."
 herramientasPermitidas: [Read, Write, Glob]
 exclusiones:
   - "No cargar para aplicaciones Next.js con App Router — Next.js tiene patrones de Server Components, SSR y caché que difieren del backend Node puro; cargar `nextjs-experto`."
@@ -324,6 +324,200 @@ Verificar siempre `process.env.WEBHOOK_URL` antes de llamar — sin config reque
 
 ---
 
+## Patrones de readline + prompts asíncronos
+
+### NUNCA: usar `rl.question(cb)` envuelto en Promise sin manejar el cierre
+
+**Problema**: `readline.Interface.question(prompt, callback)` solo invoca el
+callback cuando el usuario presiona Enter con input válido. Si el stream
+`stdin` se cierra antes (Ctrl+C, EOF, pipe roto, error), el callback nunca
+se ejecuta y el Promise queda colgado para siempre. Cualquier código que
+dependa de ese resolve (spinners pausados, locks, cleanup) queda bloqueado.
+
+```javascript
+// MAL — Promise huérfano si stdin se cierra antes del input
+function preguntarSiNo(mensaje) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`${mensaje} [s/N] `, (respuesta) => {
+      rl.close();
+      resolve(respuesta.trim().toLowerCase() === 's');
+    });
+    // Si el usuario presiona Ctrl+C, rl emite 'close' pero el callback
+    // de question() nunca corre. Promise queda colgado.
+  });
+}
+```
+
+```javascript
+// BIEN — 'close' como única ruta de finalización + flag idempotente
+function preguntarSiNo(mensaje, valorDefault = false) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+
+    let valorFinal = valorDefault;
+    let resuelto = false;
+
+    function finalizar() {
+      if (resuelto) return;
+      resuelto = true;
+      resolve(valorFinal);
+    }
+
+    // 'close' se dispara SIEMPRE: input válido (tras rl.close()),
+    // Ctrl+C, EOF, error. Garantiza resolución del Promise.
+    rl.on('close', finalizar);
+
+    rl.question(`${mensaje} [s/N] `, (respuesta) => {
+      valorFinal = respuesta.trim().toLowerCase() === 's';
+      rl.close(); // dispara 'close' → finalizar(); idempotente vía `resuelto`
+    });
+  });
+}
+```
+
+**Regla de oro**: el callback de `rl.question` NUNCA debe llamar `resolve()`
+directamente. Solo debe **setear el valor final** y llamar `rl.close()`. El
+listener `rl.on('close', ...)` es el único punto que llama `resolve()`.
+
+### NUNCA: ejecutar `setInterval` que escriba a stdout durante un prompt readline
+
+**Problema**: un spinner que escribe `\r ⠏ Procesando...   ` cada 80ms sobre
+stdout sobrescribe el prompt renderizado por `readline.createInterface()`.
+El cursor lógico de readline está en el lugar correcto, pero la
+representación visual queda mezclada — el usuario ve algo como
+`⠏ Procesando...   ntes? [S/n]` (fragmentos del prompt cortados).
+
+```javascript
+// MAL — race entre spinner y prompt
+const sp = spinner('Cargando datos...');  // setInterval cada 80ms
+try {
+  const datos = await fetchDatos();
+  if (necesitaConfirmacion(datos)) {
+    // BUG: el spinner sigue escribiendo \r mientras readline renderiza el prompt
+    const confirma = await preguntarSiNo('¿Continuar?');
+  }
+} finally {
+  sp.detener();
+}
+```
+
+```javascript
+// BIEN — registro global de spinners + pausa coordinada
+const _spinnersActivos = new Set();
+
+function _pausarSpinnersActivos() {
+  for (const sp of _spinnersActivos) sp._pausar(); // clearInterval + limpiarLinea
+}
+function _reanudarSpinnersActivos() {
+  for (const sp of _spinnersActivos) sp._reanudar(); // re-setInterval si sigue activo
+}
+
+function spinner(mensaje) {
+  let pausado = false, intervalo = null;
+  function _arrancarIntervalo() {
+    if (!intervalo) intervalo = setInterval(tick, 80);
+  }
+  const handle = {
+    _pausar() {
+      if (pausado) return;
+      pausado = true;
+      if (intervalo) { clearInterval(intervalo); intervalo = null; }
+      process.stdout.write('\r\x1b[2K');  // limpiar línea para el prompt
+    },
+    _reanudar() {
+      if (!pausado) return;
+      pausado = false;
+      _arrancarIntervalo();
+    },
+    detener() {
+      _spinnersActivos.delete(handle);
+      if (intervalo) clearInterval(intervalo);
+    },
+  };
+  _spinnersActivos.add(handle);
+  _arrancarIntervalo();
+  return handle;
+}
+
+// preguntarSiNo pausa antes de createInterface y reanuda en finalizar
+function preguntarSiNo(mensaje) {
+  return new Promise((resolve) => {
+    _pausarSpinnersActivos();
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    let resuelto = false;
+    rl.on('close', () => {
+      if (resuelto) return;
+      resuelto = true;
+      _reanudarSpinnersActivos();
+      resolve(valorFinal);
+    });
+    // ... rl.question como en el patrón anterior
+  });
+}
+```
+
+### NUNCA: registrar listeners en `process` desde un spinner sin removerlos
+
+**Problema**: un spinner registra `process.once('exit', cleanup)` al
+crearse. Si el spinner termina con éxito (no por exit del proceso), el
+listener queda colgado en `process`. Un loop que crea N spinners
+secuenciales (un instalador iterando runtimes) acumula N listeners hasta
+disparar `MaxListenersExceededWarning` con default 10.
+
+```javascript
+// BIEN — declarar exitHandler antes del handle y removerlo en terminación
+function spinner(mensaje) {
+  // Declarado antes del handle para que las funciones de terminación
+  // puedan removerlo. Closure: la arrow function captura la binding de
+  // `handle`, no su valor — se resuelve al invocar 'exit'.
+  const exitHandler = () => { handle.detener(); };
+
+  const handle = {
+    exito(msg) {
+      // ... limpieza interna
+      process.removeListener('exit', exitHandler);  // ← OBLIGATORIO
+      console.log(`  ✓ ${msg}`);
+    },
+    fallo(msg) {
+      process.removeListener('exit', exitHandler);  // ← OBLIGATORIO
+      console.log(`  ✗ ${msg}`);
+    },
+    detener() {
+      process.removeListener('exit', exitHandler);  // ← OBLIGATORIO
+    },
+  };
+
+  process.once('exit', exitHandler);
+  return handle;
+}
+```
+
+Para verificar que no hay leak en tests:
+
+```javascript
+test('spinner: no acumula listeners en process al iterar', () => {
+  const antes = process.listenerCount('exit');
+  for (let i = 0; i < 12; i++) {
+    const sp = spinner(`iter-${i}`);
+    if (i % 3 === 0) sp.exito(`ok-${i}`);
+    else if (i % 3 === 1) sp.fallo(`err-${i}`);
+    else sp.detener();
+  }
+  const despues = process.listenerCount('exit');
+  assert.equal(despues, antes, 'listeners no removidos');
+});
+```
+
+**Detección iterativa con `/swl:nemesis --remediar`**: este patrón
+(race spinner/prompt + premature close + listener leak) emergió en swl-ses
+v1.6.0 tras 3 iteraciones de fix. La primera detectó el race obvio; Cursor
+IDE detectó el premature close en revisión estática del fix; nemesis iter-2
+detectó el listener leak (F-1) y `preguntarOpcion` pausando tarde (F-2).
+Lección operativa: para módulos pequeños con alta densidad de control de
+flujo (event handlers, callbacks, setInterval/setTimeout, readline),
+nemesis con `--remediar` es costo-efectivo (~15 turnos para ~300 LOC).
+
 ## Scripts dual-use: librería + CLI
 
 ### `require.main === module` para scripts en `scripts/lib/`

package/habilidades/prevencion-racionalizacion/SKILL.md

@@ -6,6 +6,7 @@ description: >
   red flags de pensamiento y técnicas para construir skills resistentes a la
   racionalización. Cargar al diseñar skills, al detectar agentes saltando procesos,
   o al revisar por qué un agente no siguió un paso obligatorio.
+version: "1.0.0"
 herramientasPermitidas: [Read, Grep]
 exclusiones:
   - "No cargar para prevenir sobre-ingeniería o cambios fuera del scope — ese es `prevencion-sobreingenieria`; este skill trata racionalización de *omisión* de pasos obligatorios, no de *adición* innecesaria de complejidad."

package/habilidades/privacy-memoria/SKILL.md

@@ -5,6 +5,7 @@ description: >
   sensible, y mejores prácticas para proteger datos en aprendizajes y sesiones.
   Cargar cuando se trabaje con datos sensibles, se configure el sistema de memoria
   o se implementen componentes que lean/escriban APRENDIZAJES.md o session-store.
+version: "1.0.0"
 herramientasPermitidas: [Read, Write]
 evolvable: false  # bloqueado por lista (skill de seguridad/privacidad)
 nist_csf: [GV.OV-01, PR.DS-01, PR.DS-02, DE.CM-09]

package/habilidades/sre-patrones/SKILL.md

@@ -303,7 +303,7 @@ Ejemplo incorrecto: "Juan olvidó activar el health check."]
 | Chaos engineering: steady state, herramientas, safety | [recursos/chaos-engineering.md](recursos/chaos-engineering.md) |
 | On-call: rotación, escalación, fatiga de alertas | [recursos/oncall-design.md](recursos/oncall-design.md) |
 | Alertas Prometheus con runbook completo | `Skill("monitoring-alertas")` |
-| Implementación de métricas en código | `Skill("observabilidad-swl")` |
+| Implementación de métricas en código | Invocar `Agent(subagent_type="observabilidad-swl")` — es agente, no skill |
 
 ---