@saulwade/swl-ses 1.8.0 → 2.0.0

package/reglas/memoria-consolidada.md

@@ -160,7 +160,7 @@ const conFeedback = applyFeedback(instinto, 'helpful');
 ```
 
 **Cuándo recomputar**:
-- `/swl:salud` reporta instintos con `effective_confidence < 0.3` para revisión.
+- `/swl:status salud` reporta instintos con `effective_confidence < 0.3` para revisión.
 - `hooks/degradacion-instintos.js` puede marcar `status_proposed: degraded`
   cuando `shouldAutoDeprecate(instinto)` devuelve `true`.
 - `bootstrap-instintos.js` emite los nuevos instintos con `decay_half_life_days: 90`,

package/reglas/patrones.md

@@ -1,3 +1,9 @@
+---
+paths:
+  - "**/*.tsx"
+  - "**/*.jsx"
+  - "**/next.config.{js,mjs,ts}"
+---
 # Regla: Patrones de Arquitectura — Next.js (App Router)
 
 El App Router de Next.js cambia fundamentalmente dónde y cómo se cargan datos.

package/reglas/registro-componentes-nuevos.md

@@ -1,3 +1,12 @@
+---
+paths:
+  - "**/manifiestos/**"
+  - "**/agentes/**"
+  - "**/habilidades/**"
+  - "**/comandos/**"
+  - "**/hooks/**"
+  - "**/plugin.json"
+---
 # Regla: Registro obligatorio de componentes nuevos en manifiestos
 
 Esta regla es OBLIGATORIA para el proyecto **@saulwade/swl-ses**. Aplica
@@ -26,7 +35,7 @@ propagación de cambios" del `CLAUDE.md` del proyecto.
 
 El costo de registrar es ~30 segundos por componente (3 archivos a editar
 + un comando de regeneración). El costo de no registrar es: instalador roto
-para usuarios del paquete público, `npm run test:all` falla, `/swl:salud`
+para usuarios del paquete público, `npm run test:all` falla, `/swl:status salud`
 reporta degradación, deuda acumulada difícil de detectar tras varios commits.
 
 ---

package/reglas/seguridad-agentes.md

@@ -335,7 +335,7 @@ Precedente: ADR-0002 (skills) y ADR-0004 (agentes). Agregar Exclusion a un agent
 
 ### Auditoría
 
-`scripts/auditar-agentes-gaps.js` reporta cobertura. Integración con `/swl:salud`
+`scripts/auditar-agentes-gaps.js` reporta cobertura. Integración con `/swl:status salud`
 mediante `SWL_AUDIT_AGENTES=1` (paso 5d).
 
 ### Ejemplo de frontmatter

package/reglas/seguridad.evolved.json

@@ -0,0 +1,7 @@
+{
+  "evolved": true,
+  "evolved-from": "1.8.0",
+  "evolved-at": "2026-06-04",
+  "evolved-by": "evolucionar",
+  "evolved-note": "PE-003 (verificación de flags antes de asumir servicios externos LDAP/Redis/S3) + PE-004 (sanitización PII centralizada en handlers) + PE-007 (generación de passwords legibles sin chars ambiguos). Origen: OIC v1.5 2026-06-04, bug histórico manuel.monteagudo + Slice 2 v1.5 Observabilidad."
+}

package/reglas/seguridad.md

@@ -141,6 +141,147 @@ vulnerabilidad del OWASP Top 10. Las más frecuentes en este stack:
 
 ---
 
+## Verificación obligatoria de flags de configuración antes de asumir servicios externos
+
+Toda rama de código que asuma un servicio externo opcional (LDAP, Redis, S3, SMTP,
+OIDC, Auth0, etc.) DEBE verificar el flag de configuración del proyecto ANTES de
+tomar la decisión. Sin esta verificación, una configuración no esperada deja a los
+usuarios atrapados en flujos rotos sin error visible.
+
+**Anti-patrón** (caso real OIC 2026-06-04, dos bugs históricos en el mismo flujo):
+
+```python
+# MAL — asume LDAP siempre habilitado
+if rol == "ADMIN":
+    hashed = hash_password(body.password)
+else:
+    # "Para usuarios LDAP, no se almacena contraseña funcional local."
+    hashed = hash_password(uuid.uuid4().hex)
+    # ↑ Si AUTH_LDAP_ENABLED=false (caso real), el usuario queda con un hash
+    # UUID dummy que ninguna password real puede igualar → 401 perpetuo.
+```
+
+```python
+# MAL — rechaza no-ADMIN sin verificar si LDAP existe siquiera
+if rol != "ADMIN":
+    raise HTTPException(400, "Los usuarios no ADMIN gestionan su contraseña en LDAP")
+    # ↑ Sin LDAP habilitado los usuarios no tienen forma de cambiar password.
+```
+
+**Patrón correcto**:
+
+```python
+# BIEN — siempre verifica el flag antes de asumir el servicio
+if rol == "ADMIN":
+    hashed = hash_password(body.password)
+else:
+    if body.password:
+        hashed = hash_password(body.password)
+    elif not settings.AUTH_LDAP_ENABLED:
+        # Sin LDAP: generar password funcional para que el usuario pueda entrar
+        temp = _generar_temp_password()
+        hashed = hash_password(temp)
+        # devolver `temp` en la respuesta del POST UNA SOLA VEZ
+    else:
+        # LDAP habilitado: dummy OK porque el usuario se autentica fuera
+        hashed = hash_password(uuid.uuid4().hex)
+```
+
+**Detección temprana en code review**: cualquier comentario `"para LDAP"`,
+`"para Redis"`, `"para S3"` debe acompañarse del check del flag correspondiente.
+Si el comentario está solo, es bug latente — el código asume un mundo que el
+deployment puede no tener.
+
+---
+
+## Sanitización PII centralizada en handlers vs refactorear N sitios
+
+Cuando un sistema persiste logs estructurados (audit trails, error logs,
+telemetría) y existen N sitios donde el código emite `logger.error(..., extra={...})`
+con potencial PII en los valores, **siempre preferir sanitización centralizada en
+el handler** sobre refactorear cada sitio individualmente.
+
+**Decisión arquitectónica** (caso OIC v1.5 Slice 2, 2026-06-04):
+
+| Opción | Esfuerzo | Cobertura futura | Mantenimiento |
+|---|---|---|---|
+| Refactorear N sitios uno por uno | O(N) turnos | Solo lo refactorizado | Cada `logger.error` nuevo requiere auditoría |
+| Sanitización centralizada en handler | O(1) turno | Todos los sitios + futuros automáticamente | Cero auditoría manual al agregar nuevos `logger.error` |
+
+**Patrón portable**:
+
+```python
+import re
+
+_PATRON_SENSIBLE = re.compile(
+    r'(password|token|secret|jwt|authorization|cookie|api[_-]?key)([=:])([^&\s"\']+)',
+    re.IGNORECASE,
+)
+
+def sanitizar_url(url: str | None) -> str | None:
+    """Redacta query-params sensibles preservando key y separador."""
+    if not url:
+        return url
+    return _PATRON_SENSIBLE.sub(r"\1\2<redacted>", url)
+
+def sanitizar_valor(valor: Any) -> Any:
+    """Sanitiza recursivamente strings dentro de dict/list/tuple."""
+    if isinstance(valor, str):
+        return _PATRON_SENSIBLE.sub(r"\1\2<redacted>", valor)
+    if isinstance(valor, dict):
+        return {k: sanitizar_valor(v) for k, v in valor.items()}
+    if isinstance(valor, (list, tuple)):
+        return [sanitizar_valor(item) for item in valor]
+    return valor
+```
+
+**Regla del regex**:
+- Grupo 1 (key) y grupo 2 (`=` o `:`) se preservan → mantiene legibilidad
+  (`password=<redacted>` en vez de `<redacted>`).
+- Grupo 3 (valor) se reemplaza por `<redacted>`.
+- Boundary del valor: `&`, whitespace, comilla, paréntesis.
+- `api_key` y `api-key` ambos matchean con `api[_-]?key`.
+
+**Aplicabilidad**: handlers de logging custom, middleware HTTP que redactan headers,
+sanitización de cookies en logs, redactor de stack traces, error reporters
+(Sentry-style). Defensa en profundidad sin tocar el código del caller.
+
+**Limitación documentada**: el regex opera sobre strings; NO sanitiza claves cuyo
+nombre no esté en la lista (no detecta `contraseña` en español, `pwd`, `mot_de_passe`).
+Mantener el regex extensible vía configuración si el proyecto opera en múltiples idiomas.
+
+---
+
+## Generación de tokens y passwords legibles (sin caracteres ambiguos)
+
+Para passwords temporales (reset por admin, primer login, recuperación) que el
+usuario debe transcribir verbalmente o desde papel, usar alfabeto SIN caracteres
+ambiguos: `0` (cero) vs `O` (o mayúscula), `1` (uno) vs `l` (L minúscula) vs `I`
+(i mayúscula).
+
+```python
+import secrets
+
+# 54 chars del alfabeto seguro (sin 0, O, 1, l, I)
+_ALFABETO_LEGIBLE = "abcdefghijkmnpqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ23456789"
+
+def generar_password_temporal(longitud: int = 12) -> str:
+    """12 chars → ~71 bits de entropía. Suficiente para temporal que debe
+    cambiarse en primer login. NUNCA persistir en texto plano; el caller
+    la hashea con bcrypt y la devuelve UNA SOLA VEZ en la respuesta del POST."""
+    return "".join(secrets.choice(_ALFABETO_LEGIBLE) for _ in range(longitud))
+```
+
+**NO usar** `secrets.token_urlsafe()` para passwords visibles al humano: incluye
+`-` y `_` que pueden confundir al transcribir. Reservar `token_urlsafe()` para
+tokens de sesión, CSRF, magic links — strings que no se leen ni transcriben.
+
+**Para tokens de uso programático** (API keys, session IDs, refresh tokens):
+`secrets.token_urlsafe(32)` (32 bytes → 256 bits) o `secrets.token_hex(32)`. Sin
+restricción de alfabeto porque el usuario nunca los teclea manualmente.
+
+---
+
 ## Checklist antes de merge a main
 
 - [ ] No hay secrets hardcodeados (revisar con `git grep -i "password\|secret\|token\|key"`)
@@ -149,3 +290,6 @@ vulnerabilidad del OWASP Top 10. Las más frecuentes en este stack:
 - [ ] Sin uso de `eval`, `exec`, `shell=True`
 - [ ] Logs sin datos sensibles
 - [ ] Dependencias nuevas auditadas
+- [ ] Cualquier rama que asuma servicio externo (LDAP/Redis/S3) verifica su flag de config
+- [ ] Sanitización PII centralizada en handlers (no diseminada por N sitios)
+- [ ] Passwords temporales generadas con alfabeto sin chars ambiguos

package/reglas/skills-estandar.md

@@ -1,3 +1,9 @@
+---
+paths:
+  - "**/habilidades/**"
+  - "**/skills/**"
+  - "**/_userland/**"
+---
 # Regla: Estándar Oficial de Claude Agent Skills para el Sistema SWL
 
 **Aplica a**: Toda skill nueva o modificada en `habilidades/` y `skills/`

package/reglas/testing.md

@@ -1,3 +1,10 @@
+---
+paths:
+  - "**/*.tsx"
+  - "**/*.jsx"
+  - "**/vitest.config.{js,ts,mjs}"
+  - "**/playwright.config.{js,ts}"
+---
 # Regla: Testing — Next.js
 
 Probar Next.js con App Router requiere estrategia porque existen tres tipos de

package/reglas/tests-cleanup.md

@@ -1,3 +1,7 @@
+---
+paths:
+  - "**/tests/**"
+---
 # Regla: Cleanup obligatorio de directorios temporales en tests
 
 Esta regla es **OBLIGATORIA** y aplica a todo test Node.js del sistema SWL

package/reglas/usar-sistema-swl.md

@@ -78,7 +78,7 @@ de ejecutar.
 | Capturar aprendizaje recurrente | `/swl:aprender` → APRENDIZAJES.md → posible promoción a regla/skill |
 | Release con bump de versión | `/swl:release` (sincronización de ubicaciones de versión) |
 | Documentación viva post-feature | `documentador-swl` |
-| Diagnóstico del sistema | `/swl:salud` |
+| Diagnóstico del sistema | `/swl:status salud` |
 
 ### Para tareas de búsqueda y contexto
 

package/scripts/generar-inventario.js

@@ -33,7 +33,8 @@ const args = new Set(process.argv.slice(2));
 const DRY  = args.has('--dry-run');
 const SOLO_INV = args.has('--inventario');
 const SOLO_SAL = args.has('--salud');
-const AMBOS = !SOLO_INV && !SOLO_SAL;
+const SOLO_LLMS = args.has('--llms');
+const AMBOS = !SOLO_INV && !SOLO_SAL && !SOLO_LLMS;
 
 // ── Helpers ────────────────────────────────────────────────────────────
 
@@ -427,6 +428,57 @@ function generarSalud() {
   return lines.join('\n');
 }
 
+// ── llms.txt (convención llmstxt.org) ─────────────────────────────────
+// Índice raíz LLM-legible para descubrimiento externo por herramientas/agentes
+// que esperan el estándar. Cifras sincronizadas con INVENTARIO (mismo cómputo)
+// para que el gate de release no detecte drift. Adoptado de obsidian-second-brain
+// (análisis temp/ 2026-06-05); el resto de ese repo era redundante con swl-ses.
+function generarLlmsTxt() {
+  const pkg = JSON.parse(fs.readFileSync(path.join(RAIZ, 'package.json'), 'utf8'));
+  const agentes  = recolectarAgentes().length;
+  const skills   = recolectarSkills().length;
+  const hooks    = recolectarHooks().length;
+  const comandos = contarArchivos(path.join(RAIZ, 'comandos', 'swl'), '.md');
+  const reglasBase = contarArchivos(path.join(RAIZ, 'reglas'), '.md');
+  const reglasLang = fs.readdirSync(path.join(RAIZ, 'reglas', 'lenguajes'))
+    .filter(d => fs.statSync(path.join(RAIZ, 'reglas', 'lenguajes', d)).isDirectory())
+    .reduce((acc, d) => acc + contarArchivos(path.join(RAIZ, 'reglas', 'lenguajes', d), '.md'), 0);
+
+  const L = [];
+  L.push('# swl-ses (@saulwade/swl-ses)');
+  L.push('');
+  L.push(`> Sistema de ingeniería de software auto-evolutivo multi-runtime polyglot (SDLC completo), distribuido como paquete npm y plugin de Claude Code. ${agentes} agentes, ${skills} habilidades, ${comandos} comandos, ${reglasBase} reglas base y ${hooks} hooks. Soporta 11 lenguajes y 7 runtimes (Claude Code, OpenClaude, OpenCode, Gemini, Cursor, Codex, Copilot). Versión ${pkg.version}.`);
+  L.push('');
+  L.push('Archivo generado por `node scripts/generar-inventario.js` — no editar a mano. Las cifras se sincronizan con INVENTARIO.md en cada regeneración.');
+  L.push('');
+  L.push('## Documentación');
+  L.push('');
+  L.push('- [README](README.md): overview público y quickstart');
+  L.push('- [Manual de uso](MANUAL_USO.md): manual operacional completo');
+  L.push('- [Comandos](COMANDOS.md): referencia detallada de cada comando `/swl:*`');
+  L.push('- [Agentes](AGENTS.md): catálogo de agentes con capacidades');
+  L.push('- [Inventario](INVENTARIO.md): conteos oficiales de todos los componentes');
+  L.push('- [Instalación](INSTALACION.md): instalación, perfiles y configuración');
+  L.push('- [Instrucciones del proyecto](CLAUDE.md): convenciones, stack y reglas');
+  L.push('');
+  L.push('## Componentes');
+  L.push('');
+  L.push(`- ${agentes} agentes especializados en \`agentes/\` (orquestación, implementación por stack, revisión, calidad, diseño)`);
+  L.push(`- ${skills} habilidades cargables bajo demanda en \`habilidades/\` (conocimiento operacional con divulgación progresiva)`);
+  L.push(`- ${comandos} comandos \`/swl:*\` en \`comandos/swl/\` (ciclo GSD, calidad, release, diagnóstico)`);
+  L.push(`- ${reglasBase} reglas base + ${reglasLang} reglas por lenguaje en \`reglas/\` (políticas obligatorias por matcher)`);
+  L.push(`- ${hooks} hooks en \`hooks/\` (telemetría, validación, seguridad; zero-deps, escrituras atómicas)`);
+  L.push('');
+  L.push('## Opcional');
+  L.push('');
+  L.push('- [CHANGELOG](CHANGELOG.md): historial de versiones');
+  L.push('- [Índice de ADRs](.planning/adrs/README.md): decisiones de arquitectura');
+  L.push('- [Variables de entorno](docs/variables-entorno.md): configuración opt-in');
+  L.push('');
+
+  return L.join('\n');
+}
+
 // ── Ejecutar ──────────────────────────────────────────────────────────
 
 if (AMBOS || SOLO_INV) {
@@ -450,3 +502,14 @@ if (AMBOS || SOLO_SAL) {
     console.log('SALUD.md generado correctamente.');
   }
 }
+
+if (AMBOS || SOLO_LLMS) {
+  const llms = generarLlmsTxt();
+  if (DRY) {
+    console.log('\n=== llms.txt (dry-run) ===\n');
+    console.log(llms);
+  } else {
+    atomicWriteSync(path.join(RAIZ, 'llms.txt'), llms, 'utf8');
+    console.log('llms.txt generado correctamente.');
+  }
+}

package/scripts/instalador.js

@@ -210,10 +210,30 @@ async function install(opciones) {
   // 2b. Filtrar reglas de lenguaje por stack detectado
   // El stack se detecta siempre que: hay reglas de lenguaje en el perfil, O
   // se ejecuta con --force (actualización) para poder limpiar las ya instaladas.
+  // FIX (thrashing de contexto en subagentes): en scope GLOBAL las reglas
+  // por-lenguaje NO se instalan en ~/.claude/rules/. Global no tiene un proyecto
+  // que detectar, así que se instalarían los 8 lenguajes (~69K tokens) y
+  // saturarían la ventana de todo subagente que herede ~/.claude/rules/. Las
+  // reglas por-lenguaje viven project-scoped, donde el stack-filter sí aplica.
+  if (esGlobal) {
+    const antesGlobal = resolucion.archivos.length;
+    resolucion.archivos = resolucion.archivos.filter(
+      a => !(a.rutaRelativa && a.rutaRelativa.startsWith('reglas/lenguajes/'))
+    );
+    const excluidasGlobal = antesGlobal - resolucion.archivos.length;
+    if (excluidasGlobal > 0) {
+      console.log(
+        `\n[stack] Scope global: ${excluidasGlobal} regla(s) por-lenguaje excluidas ` +
+        '(se instalan project-scoped, filtradas por stack; no en ~/.claude/rules/ ' +
+        'para no saturar el contexto de subagentes).'
+      );
+    }
+  }
+
   const tieneReglasLenguaje = resolucion.archivos.some(
     a => a.rutaRelativa && a.rutaRelativa.startsWith('reglas/lenguajes/')
   );
-  const necesitaStack = (tieneReglasLenguaje || force) && !allLangs;
+  const necesitaStack = (tieneReglasLenguaje || force) && !allLangs && !esGlobal;
 
   let stackDetectado = null;
 
@@ -224,7 +244,7 @@ async function install(opciones) {
   // FIX v1.6.6: si el usuario pasa --all-langs pero el perfil actual no incluye
   // reglas/lenguajes/, el flag se ignora silenciosamente. Antes la única pista
   // era el conteo final de archivos. Ahora emitimos warning explícito.
-  if (allLangs && !tieneReglasLenguaje) {
+  if (allLangs && !tieneReglasLenguaje && !esGlobal) {
     console.log(
       '\n[stack] Aviso: --all-langs ignorado — el perfil actual (' +
       (resolucion.perfil || 'core') +
@@ -269,6 +289,16 @@ async function install(opciones) {
     }
   }
 
+  // Scope global: purgar TODAS las reglas por-lenguaje preexistentes de
+  // ~/.claude/rules/ (instalaciones previas dejaban los 8 lenguajes always-loaded,
+  // saturando el contexto de subagentes). Corre en cada install global, no solo --force.
+  if (esGlobal && rutas.reglas) {
+    const purgaGlobal = limpiarReglasSinStack(rutas.reglas, new Set());
+    if (purgaGlobal.eliminados > 0) {
+      console.log(`\n[stack] Scope global: ${purgaGlobal.eliminados} subdir(s) de reglas por-lenguaje purgadas de ~/.claude/rules/ (${purgaGlobal.lenguajes.join(', ')}) — viven project-scoped.`);
+    }
+  }
+
   // 4. Detectar _userland/
   const userlandAgentes = path.join(process.cwd(), '_userland', 'agentes');
   const userlandHabilidades = path.join(process.cwd(), '_userland', 'habilidades');

package/scripts/lib/gitignore-manifest.js

@@ -79,7 +79,13 @@ const ENTRADAS_BASE = [
   // artefactos del proyecto usuario.
   ".planning/evolution/",
   ".planning/auto-evolution/",
-  ".planning/locks/",
+  // locks/: contenido runtime ignorado (singleton-guard {pid,ts},
+  // fase-activa.json) EXCEPTO los plan-locks de G1 (*PLAN.md.lock), que son
+  // evidencia de aprobación versionable (audit trail SDD — aprobar-plan.md).
+  // Patrón `dir/*` + negación: git no re-incluye archivos si el DIRECTORIO
+  // está ignorado, por eso se ignora el contenido y no el dir.
+  ".planning/locks/*",
+  "!.planning/locks/*PLAN.md.lock",
   ".planning/user-profile/",
 
   // Instintos modificados automáticamente por hooks (degradacion-instintos.js)
@@ -87,6 +93,28 @@ const ENTRADAS_BASE = [
 
   // Base de datos de uso
   "usage.db",
+
+  // ── Runtime adicional: derivados regenerables, caches y telemetría ──
+  // Cobertura completada en Fase 09 tras auditar qué genera SWL en proyectos
+  // destino vs lo que ENTRADAS_BASE propagaba. Todo esto es output de runtime,
+  // regenerable, no editado por el equipo → no se commitea.
+  ".planning/feature-list.json",          // derivar-feature-list.js (derivado de HOJA-RUTA.md)
+  ".planning/loops/",                     // loop-telemetry.js (/swl:verificar, /swl:status loops)
+  ".planning/archive/",                   // rotar-audit-auto.js (audit/logs rotados y comprimidos)
+  ".planning/analysis/",                  // outputs de análisis
+  ".planning/graph.json",                 // code-review-graph (cache del grafo)
+  ".planning/graph-cache.json",           // code-review-graph (cache incremental)
+  ".planning/mcp-snapshot.json",          // /swl:status (smoke test MCP) / mcp-status
+  ".planning/skill-index.json",           // /swl:skill-search (índice FTS de skills)
+  ".planning/inventario-aviso-state.json", // throttle del aviso de inventario
+  ".planning/*.lock",                     // locks sueltos (ej. STATE.md.lock; el dir locks/ ya está arriba)
+
+  // Estado runtime de /swl:verificar --until-converge. Vive DENTRO de
+  // .planning/fases/, que SÍ contiene plantillas commiteadas
+  // (0N-CONTEXTO/PLAN/RESUMEN/VERIFICACION.md). Glob específico para ignorar
+  // SOLO el estado de convergencia, nunca esas plantillas.
+  ".planning/fases/*-converge-state.json",
+  ".planning/fases/*-converge-run-*.json",
 ];
 
 // Entradas adicionales por runtime (se agregan cuando install usa ese target)