@saulwade/swl-ses 1.0.0 → 1.1.1

package/agentes/ux-disenador-swl.md

@@ -9,7 +9,7 @@ description: >
   disenador-ui-swl (capa visual y tokens). NO invocar para implementacion de
   codigo — produce specs, no codigo. Para implementar usar frontend-*-swl con
   la UI-SPEC.md producida.
-tools: Read, Write, Grep, Glob, WebSearch
+tools: [Read, Write, Grep, Glob, WebSearch]
 model: claude-sonnet-4-6
 modeloAlterno: claude-haiku-4-5-20251001
 ventanaContexto: 200k
@@ -17,18 +17,14 @@ permissionMode: plan
 color: pink
 version: 1.0.0
 nivelRiesgo: BAJO
-skillsInvocables: ux-diseno, wireframes-flujos, design-tokens, accesibilidad-a11y, diseno-responsivo
-skillsRestringidos:
-  - fastapi-python
-  - django-expert
-  - postgresql-table-design
-  - python-patterns
-  - angular-component
-  - angular-forms
+skillsInvocables: [ux-diseno, wireframes-flujos, design-tokens, accesibilidad-a11y, diseno-responsivo]
+skillsRestringidos: [fastapi-python, django-expert, postgresql-table-design, python-patterns, angular-component, angular-forms]
 permisosRed: true
 permisosEscritura: true
 permisosComandos: false
 evolvable: true  # nivelRiesgo=BAJO
+fase: plan
+dominio: ux
 exclusiones:
   - "No invocar para implementar código de interfaz — este agente produce UI-SPEC.md, no código; usar frontend-react-swl, frontend-angular-swl o frontend-swl para la implementación."
   - "No invocar cuando el pipeline tiene roles separados: preferir investigador-ux-swl para research y disenador-ui-swl para especificaciones visuales puras."

package/bin/swl-ses.js

@@ -64,13 +64,34 @@ function verificarCoherenciaVersion() {
     }
 
     if (versionMax && compararSemver(versionMax, VERSION) === 1) {
-      process.stderr.write(
-        `\n[swl-ses] AVISO: CLI desactualizado — ejecutando v${VERSION}, pero tu instalación SWL es v${versionMax}.\n` +
-        `[swl-ses] npm tiene cacheada una versión vieja. Para usar la versión correcta:\n` +
-        `[swl-ses]   npx @saulwade/swl-ses@latest <comando>\n` +
-        `[swl-ses] O limpia la caché de npx:\n` +
-        `[swl-ses]   npx clear-npx-cache\n\n`
+      const localPS  = parseSemver(versionMax);
+      const cliPS    = parseSemver(VERSION);
+      // Tras el rebrand 2026-04-30, el CLI nuevo @saulwade/swl-ses
+      // arrancó en v1.0.0 mientras el paquete legacy (@saulwadeleon/...
+      // o swl-ses sin scope) estaba en 5.13.1. Si la diferencia de
+      // major es ≥3 hacia abajo del CLI nuevo, NO es "desactualizado":
+      // el state apunta a una instalación previa al rebrand. En ese
+      // caso emitimos un aviso DIFERENTE: "reinstala para sincronizar".
+      const esDriftDePaqueteLegacy = (
+        localPS && cliPS &&
+        localPS[0] >= 5 && cliPS[0] === 1 &&
+        (localPS[0] - cliPS[0]) >= 3
       );
+      if (esDriftDePaqueteLegacy) {
+        process.stderr.write(
+          `\n[swl-ses] Detectada instalación previa del paquete legacy (v${versionMax}).\n` +
+          `[swl-ses] El sistema fue renombrado a @saulwade/swl-ses con SemVer reset (v${VERSION}).\n` +
+          `[swl-ses] Para sincronizar: npx @saulwade/swl-ses@latest install --target claude --profile <perfil> --force\n\n`
+        );
+      } else {
+        process.stderr.write(
+          `\n[swl-ses] AVISO: CLI desactualizado — ejecutando v${VERSION}, pero tu instalación SWL es v${versionMax}.\n` +
+          `[swl-ses] npm tiene cacheada una versión vieja. Para usar la versión correcta:\n` +
+          `[swl-ses]   npx @saulwade/swl-ses@latest <comando>\n` +
+          `[swl-ses] O limpia la caché de npx:\n` +
+          `[swl-ses]   npx clear-npx-cache\n\n`
+        );
+      }
     }
   } catch { /* nunca bloquear el CLI por este check */ }
 }

package/comandos/swl/evaluar-skill.md

@@ -356,6 +356,24 @@ Asignar badge:
 < 60  → Sin badge — no hacer merge hasta corregir
 ```
 
+### Gate de promoción para auto-evolucion-swl (G8)
+
+Este comando es el **gate obligatorio** del flujo de promoción de skills
+auto-generados desde `_userland/plugins/` a `habilidades/`. El agente
+`auto-evolucion-swl` invoca este comando antes de mover un skill al core
+(ver `agentes/auto-evolucion-swl.md` sección "Gate G8").
+
+Umbral de promoción:
+
+| Badge | Acción de auto-evolucion |
+|-------|-------------------------|
+| Platino, Oro, Plata | Promover a `habilidades/`, registrar en manifiestos |
+| Bronce | NO promover, devolver a `_userland/` con feedback |
+| Sin badge | NO promover, registrar rechazo en `.planning/evolucion/promociones-rechazadas.jsonl` |
+
+Si un skill es rechazado ≥3 veces consecutivas, el agente escala al usuario
+con análisis de qué dimensiones bajan el score. Origen: ADR 0013 sección 3C.
+
 ## Paso 4 — Emitir reporte
 
 Generar el siguiente reporte directamente en la conversación:

package/comandos/swl/evolucion-estado.md

@@ -38,6 +38,30 @@ Si el archivo no existe: ejecutar el regenerado del Paso 0. Si sigue sin
 existir: reportar "el ciclo de evolución no ha corrido aún; ejecuta cualquier
 tarea para poblar métricas iniciales".
 
+## Paso 1.5 — Cargar contexto del kernel (gobernanza)
+
+Para el bloque **KERNEL** del dashboard, recolectar:
+
+```bash
+# 1. Conteo de agentes evolvable=false vs total
+TOTAL=$(ls agentes/*.md | grep -v "^agentes/_" | wc -l)
+EVOL_FALSE=$(grep -l '^evolvable: false' agentes/*.md | wc -l)
+
+# 2. Último ADR del repo madre — el más reciente por fecha en frontmatter
+ULTIMO_ADR=$(ls .planning/adrs/[0-9]*.md | sort -r | head -1)
+TITULO=$(head -1 "$ULTIMO_ADR" | sed 's/^# //')
+FECHA=$(grep -m1 '^\*\*Fecha\*\*:' "$ULTIMO_ADR" | sed 's/.*\*\*Fecha\*\*:\s*//')
+
+echo "ADR_KERNEL_LINEA=\"$TITULO — $FECHA\""
+echo "RATIO=\"$EVOL_FALSE/$TOTAL\""
+```
+
+Estos valores alimentan la sección KERNEL del template.
+
+Si `.planning/evolucion/politica-evolvable.md` no existe, reportar como
+hallazgo crítico: el kernel SIN política documentada es violación de
+`reglas/gobernanza.md`.
+
 ## Paso 2 — Emitir el dashboard (formato humano)
 
 Template de salida:
@@ -74,6 +98,26 @@ Template de salida:
     Aplicadas ............. <n>
     Revertidas ............ <n>
     Neta .................. <n>
+    Rollback ratio ........ <%>   (N/A si aplicadas == 0)
+
+  CALIDAD CONDUCTUAL (14d)
+    Fallos por tipo:
+      bad_output_format   <n>
+      tool_error          <n>
+      timeout             <n>
+      schema_violation    <n>
+      task_incomplete     <n>
+      unknown             <n>
+    Reintentos consecutivos
+      Total ............... <n>   (mismo agente, misma task, ≤30 min)
+      Top agente .......... <agente>: <n>
+    Latencia top agente
+      Mediana ............. <ms>
+      p95 ................. <ms>
+    Sin instrumentación todavía:
+      • precision_routing_fase_dominio
+      • utilidad_memoria_recuperada
+      • violaciones_formato_post_ejecucion
 
   ALERTAS PERSISTENTES
     <si alertasActivas.length === 0>
@@ -82,6 +126,11 @@ Template de salida:
       [!] kind=X target=Y count=Z (primera: fecha)
       ...
 
+  KERNEL (gobernanza)
+    Política evolvable .... .planning/evolucion/politica-evolvable.md
+    Último ADR kernel ..... <ADR-NNNN — título — fecha>
+    Agentes evolvable=false <n>/<total>
+
 ═══════════════════════════════════════════════════════════════
 ```
 

package/comandos/swl/release.md

@@ -122,6 +122,21 @@ Para proyectos no-SWL: actualiza los archivos detectados en Paso 1 (package.json
 
 En ambos casos, verificar consistencia después de actualizar con `grep -r "versión-anterior" .` para detectar referencias olvidadas.
 
+## Paso 6.5 — Regenerar skills-lock.json
+
+Antes del CHANGELOG, regenerar el lock de skills para capturar el estado de
+los 151 SKILL.md de la release:
+
+```bash
+node scripts/generar-skills-lock.js
+git add manifiestos/skills-lock.json
+```
+
+El lock contiene SHA256 de cada SKILL.md y permite que `/swl:salud` detecte
+drift silencioso entre releases. Si el lock no cambió respecto al anterior,
+el commit lo refleja como no-op (idempotente). El archivo es pequeño (~37KB)
+y debe versionarse.
+
 ## Paso 7 — Generar CHANGELOG
 
 Lee CHANGELOG.md existente (o créalo). Agrega entrada al inicio con formato Keep a Changelog:
@@ -178,6 +193,32 @@ Resultado: 13/15 OK, 2 FALLA(S) obligatoria(s)
 
 Esta gate existe porque el agente `release-manager-swl` ha omitido archivos en 3 releases consecutivos (5.10.3, 5.10.4, 5.10.5 — ver APRENDIZAJES.md) pese a tener la checklist documentada en su frontmatter. Un checklist textual no basta: se necesita ejecución.
 
+### 10.1.1 Gate de cobertura por lenguaje (regeneración obligatoria)
+
+Tras el verificar-release.js, regenerar la matriz lenguaje × cobertura SWL:
+
+```bash
+node scripts/generar-matriz-lenguajes.js
+```
+
+El script reescribe `.planning/cobertura-lenguajes.md` con el estado actual.
+Comparar contra el commit anterior:
+
+```bash
+git diff .planning/cobertura-lenguajes.md
+```
+
+Si algún lenguaje **bajó de status** (completo → parcial, parcial → faltante)
+sin ADR documentado en `.planning/adrs/` justificando la regresión, **NO hacer
+release**. La regresión silenciosa de cobertura erosiona la promesa "polyglot"
+del repo.
+
+Si el cambio es esperado (eliminación deliberada de un componente), el ADR
+debe existir con número y fecha y referenciarse en el commit del release.
+
+Lo mismo aplica para releases con incremento de cobertura: la nueva matriz se
+commitea junto al release y se menciona en RELEASE-NOTES.
+
 ### 10.2 Verificación manual post-gate
 
 ```bash

package/comandos/swl/salud.md

@@ -286,6 +286,29 @@ Si `SWL_AUDIT_AGENTES` no está definida, este paso se omite — los reportes
 son opt-in por diseño (CLAUDE.md: "Variables de entorno opt-in para
 integraciones enterprise").
 
+## Paso 5e — Verificación de drift de skills (skills-lock)
+
+Si existe `manifiestos/skills-lock.json`, comparar el hash actual de cada
+`habilidades/*/SKILL.md` contra el lock. Detecta ediciones silenciosas de
+skills entre release y release.
+
+```bash
+node scripts/generar-skills-lock.js --check
+```
+
+Estados posibles:
+
+| Salida | Significado | Acción |
+|--------|-------------|--------|
+| `✓ skills-lock OK: N skills sin drift` | Todos los hashes coinciden | Continuar |
+| `✗ skills-lock DRIFT detectado` | Skills modificados, nuevos o faltantes | Listar diferencias y proponer regenerar |
+
+Si NO existe el lock (proyecto fresco o pre-1.1.0), este paso se omite y
+emite advertencia sugerente: `node scripts/generar-skills-lock.js`.
+
+El lock se regenera automáticamente como parte de `/swl:release`. Drift
+fuera de release indica ediciones manuales no committed.
+
 ## Paso 6b — Formato de salida enriquecido (HealthRow)
 
 El módulo `scripts/lib/health-row.js` genera filas de salud con formato visual enriquecido

package/hooks/auto-evolucion.js

@@ -42,6 +42,15 @@
 const fs   = require('fs');
 const path = require('path');
 
+// Escritura atómica obligatoria para estado mutable (regla CLAUDE.md).
+// Fallback defensivo si el módulo no existe en el destino.
+let atomicWriteJSON;
+try {
+  ({ atomicWriteJSON } = require('./lib/atomic-write'));
+} catch {
+  atomicWriteJSON = (p, obj) => fs.writeFileSync(p, JSON.stringify(obj, null, 2), 'utf8');
+}
+
 let nudgeTracker;
 try {
   nudgeTracker = require('./lib/nudge-tracker');
@@ -70,6 +79,13 @@ try {
   driftDetector = null;
 }
 
+let agentRouting;
+try {
+  agentRouting = require('./lib/agent-routing');
+} catch {
+  agentRouting = null;
+}
+
 let singletonGuard;
 try {
   singletonGuard = require('./lib/singleton-guard');
@@ -120,7 +136,7 @@ function leerNudges() {
 function escribirNudges(obj) {
   ensureDir(DIR_AUTOEVOL);
   try {
-    fs.writeFileSync(NUDGES_PATH, JSON.stringify(obj, null, 2), 'utf8');
+    atomicWriteJSON(NUDGES_PATH, obj);
   } catch { /* ignore */ }
 }
 
@@ -196,6 +212,21 @@ function analizarPayload(data) {
     ? clasificarTipoFallo(data, response)
     : null;
 
+  // Inferir fase/dominio del frontmatter del agente para routing precision
+  // (ADR 0012). Si el agente no tiene frontmatter o no se encuentra el archivo,
+  // los campos quedan null y la métrica simplemente no cuenta esa entrada.
+  let routedPhase = null;
+  let routedDomain = null;
+  let routingSource = 'unknown';
+  if (agentRouting) {
+    try {
+      const r = agentRouting.getRouting(subagentType);
+      routedPhase   = r.fase;
+      routedDomain  = r.dominio;
+      routingSource = r.source;
+    } catch { /* no bloquear por fallo en routing inference */ }
+  }
+
   return {
     ts: new Date().toISOString(),
     sessionId: String(data.session_id || 'default'),
@@ -205,6 +236,9 @@ function analizarPayload(data) {
     trivial: toolCalls > 0 && toolCalls < MIN_TOOL_CALLS,
     duracionMs,
     tipo_fallo: tipoFallo,
+    routed_phase:   routedPhase,
+    routed_domain:  routedDomain,
+    routing_source: routingSource,
   };
 }
 

package/hooks/clasificador-mensajes.js

@@ -11,14 +11,31 @@
  * arquitectura, seguridad, performance, refactor, documentación.
  *
  * Inspirado en obsidian-mind classify-message.py.
- * Zero-dependencies: regex puro en JS.
+ * Zero-dependencies: regex puro en JS + lib propia text-similarity.js.
  *
  * Resultado:
  *   - Señales detectadas → hookSpecificOutput con hints de routing
  *   - Sin señales → exit 0 silencioso
  *   - Error interno → exit 0 silencioso (nunca bloquear)
+ *
+ * Opt-in opcional:
+ *   - SWL_FUZZY_CLASIFICADOR=1 activa fuzzy matching (Levenshtein + stem ES)
+ *     como SEGUNDA pasada cuando regex no detectó señales. NUNCA degrada
+ *     señales del regex original. Útil para typos y variantes morfológicas
+ *     ("documentar" → matches "documentación"). Costo: ~5-15ms por prompt.
  */
 
+const path = require('path');
+const FUZZY_HABILITADO = process.env.SWL_FUZZY_CLASIFICADOR === '1';
+let textSim = null;
+if (FUZZY_HABILITADO) {
+  try {
+    textSim = require(path.join(__dirname, 'lib', 'text-similarity'));
+  } catch (_) {
+    // Si la lib no existe, fuzzy se desactiva silenciosamente
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Mapa de complejidad de tarea → modelo recomendado
 //
@@ -212,22 +229,52 @@ function anyMatch(patterns, text) {
   return false;
 }
 
+/**
+ * Verifica si algún patrón aparece de forma aproximada (fuzzy) en el texto.
+ * Usa Levenshtein + stem español. Solo se invoca si SWL_FUZZY_CLASIFICADOR=1.
+ * NO se llama si `anyMatch` ya devolvió true para esa señal — fuzzy es
+ * fallback puro, no reemplazo.
+ *
+ * @param {string[]} patterns
+ * @param {string} text - texto original (no lowercase necesariamente)
+ * @returns {boolean}
+ */
+function anyMatchFuzzy(patterns, text) {
+  if (!textSim) return false;
+  for (const phrase of patterns) {
+    // Solo aplicar fuzzy a patterns de palabra única o frase corta.
+    // Patterns de >3 palabras tienden a generar falsos positivos.
+    const tokens = phrase.split(/\s+/).filter(Boolean);
+    if (tokens.length > 3) continue;
+    if (textSim.fuzzyContains(text, phrase)) return true;
+  }
+  return false;
+}
+
 /**
  * Clasifica el mensaje del usuario.
  * @param {string} prompt
- * @returns {{ hints: string[], signalNames: string[] }}
+ * @returns {{ hints: string[], signalNames: string[], fuzzyAdded: number }}
  */
 function classify(prompt) {
   const text = (prompt || '').toLowerCase();
   const hints = [];
   const signalNames = [];
+  let fuzzyAdded = 0;
+
   for (const sig of SIGNALS) {
     if (anyMatch(sig.patterns, text)) {
       hints.push(sig.hint);
       signalNames.push(sig.name);
+    } else if (FUZZY_HABILITADO && anyMatchFuzzy(sig.patterns, text)) {
+      // Fuzzy detectó algo que el regex perdió — marca con [fuzzy] para
+      // observabilidad
+      hints.push(sig.hint + ' [match aproximado]');
+      signalNames.push(sig.name);
+      fuzzyAdded++;
     }
   }
-  return { hints, signalNames };
+  return { hints, signalNames, fuzzyAdded };
 }
 
 // ---------------------------------------------------------------------------

package/hooks/lib/agent-routing.js

@@ -0,0 +1,107 @@
+'use strict';
+
+/**
+ * agent-routing.js — Helper para inferir fase y dominio del routing.
+ *
+ * Lee el frontmatter del agente (agentes/<nombre>.md) y extrae los campos
+ * `fase` y `dominio` introducidos en v1.1.0 (ADR 0012). El orquestador no
+ * registra explícitamente "qué fase/dominio motivó la elección" — pero
+ * cuando elige un agente, podemos asumir que lo eligió porque su fase y
+ * dominio matcheaban. Por lo tanto, leer el frontmatter del agente
+ * efectivamente invocado nos da la celda fase×dominio del routing.
+ *
+ * Esto es proxy de precisión, no precisión absoluta:
+ *   - Tasa de éxito por celda (fase, dominio) sirve como indicador de
+ *     que el routing está enviando trabajo correctamente al agente
+ *     adecuado.
+ *   - Una celda con tasa de éxito baja sugiere routing impreciso (el
+ *     agente recibe trabajo que no le compete) o agente sub-óptimo.
+ *
+ * Cache simple en memoria del proceso para evitar I/O repetida (cada
+ * invocación de hook es proceso fresco, así que el cache no persiste,
+ * pero protege dentro de la misma invocación).
+ *
+ * @module hooks/lib/agent-routing
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const _cache = Object.create(null);
+
+/**
+ * Resuelve la ruta del archivo de agente. Acepta tanto el repo madre como
+ * proyectos consumidores (donde los agentes pueden estar en otras rutas).
+ *
+ * @param {string} agentName - p.ej. "backend-python-swl"
+ * @param {string} [cwd]     - Directorio de proyecto (default process.cwd())
+ * @returns {string|null}    - Ruta absoluta o null si no existe
+ */
+function resolveAgentPath(agentName, cwd) {
+  const baseDir = cwd || process.cwd();
+  const candidates = [
+    path.join(baseDir, 'agentes', `${agentName}.md`),
+    path.join(baseDir, '.claude', 'agents', `${agentName}.md`),
+  ];
+  for (const c of candidates) {
+    try { if (fs.statSync(c).isFile()) return c; } catch { /* siguiente */ }
+  }
+  return null;
+}
+
+/**
+ * Extrae fase y dominio del frontmatter de un agente.
+ *
+ * @param {string} agentName - Nombre del agente sin extensión
+ * @param {string} [cwd]
+ * @returns {{ fase: string|null, dominio: string|null, source: string }}
+ *   - source: 'frontmatter' | 'cache' | 'unknown'
+ */
+function getRouting(agentName, cwd) {
+  if (!agentName) return { fase: null, dominio: null, source: 'unknown' };
+  if (_cache[agentName]) {
+    return { ..._cache[agentName], source: 'cache' };
+  }
+
+  const agentPath = resolveAgentPath(agentName, cwd);
+  if (!agentPath) {
+    const result = { fase: null, dominio: null, source: 'unknown' };
+    _cache[agentName] = { fase: null, dominio: null };
+    return result;
+  }
+
+  let raw;
+  try {
+    raw = fs.readFileSync(agentPath, 'utf8');
+  } catch {
+    return { fase: null, dominio: null, source: 'unknown' };
+  }
+
+  const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!fmMatch) {
+    _cache[agentName] = { fase: null, dominio: null };
+    return { fase: null, dominio: null, source: 'unknown' };
+  }
+  const fm = fmMatch[1];
+
+  // Parser minimalista — solo busca las dos líneas que necesitamos.
+  // Evitamos depender de un parser YAML completo (zero-deps).
+  const faseMatch    = fm.match(/^fase:\s*(\S+)/m);
+  const dominioMatch = fm.match(/^dominio:\s*(\S+)/m);
+
+  const result = {
+    fase:    faseMatch    ? faseMatch[1].trim()    : null,
+    dominio: dominioMatch ? dominioMatch[1].trim() : null,
+  };
+  _cache[agentName] = result;
+  return { ...result, source: 'frontmatter' };
+}
+
+/**
+ * Limpia el cache (para tests o tras modificar agentes).
+ */
+function clearCache() {
+  for (const k of Object.keys(_cache)) delete _cache[k];
+}
+
+module.exports = { getRouting, resolveAgentPath, clearCache };