@saulwade/swl-ses 1.1.4 → 1.2.0

package/habilidades/postgresql-experto/SKILL.md

@@ -1,7 +1,12 @@
 ---
 name: postgresql-experto
 description: PostgreSQL avanzado. JSONB, arrays, tipos personalizados, búsqueda de texto completo, window functions, CTEs recursivos, Row Level Security y funciones almacenadas.
-version: "1.0.0"
+version: "1.1.0"
+evolved: true
+evolved-from: "1.0.0"
+evolved-at: "2026-05-05"
+evolved-by: "aprender"
+evolved-note: "3 gotchas nuevos de la sesión SIGM 2026-05-05: RLS bypass por superusuarios, UUIDs hex en seeds, consultar enum_range antes de seedear (L2/L4/L8)"
 herramientasPermitidas: [Read, Grep]
 exclusiones:
   - "No cargar para optimización de queries SQL (EXPLAIN ANALYZE, índices, partitioning) — para optimización cargar `sql-optimizacion`."
@@ -144,6 +149,24 @@ ver [recursos/referencia-completa.md](recursos/referencia-completa.md).
 
 **`SET LOCAL app.empresa_id` para RLS no persiste fuera de una transacción**: `SET LOCAL` establece la variable solo para la transacción actual — si se ejecuta fuera de `BEGIN/COMMIT`, tiene el mismo efecto que `SET` (sesión completa). En aplicaciones con pooling (PgBouncer en transaction mode), la sesión se reutiliza entre conexiones y la variable puede persistir de una petición anterior. Causa: el pool de conexiones reutiliza sessions sin limpiar el estado. Fix: usar SIEMPRE `SET LOCAL` dentro de una transacción explícita (`async with session.begin()`) y verificar que el pool esté en transaction mode.
 
+**RLS NO se aplica a superusuarios — verificar siempre con rol app-only**: `FORCE ROW LEVEL SECURITY` hace que las policies apliquen al OWNER de la tabla, pero los superusuarios SIEMPRE bypassean RLS. En imágenes oficiales (`postgis/postgis`, `postgres`), el rol que se crea por defecto (con `POSTGRES_USER`) es superusuario. Caso real: `SET app.tenant_id = COAT` mostraba 20 predios del tenant MINA porque la query corría como `sigm` superuser. Fix: para verificar aislamiento RLS o exponer al backend de producción, crear un rol app-only sin BYPASSRLS:
+```sql
+CREATE ROLE sigm_app NOLOGIN;
+GRANT USAGE ON SCHEMA <s> TO sigm_app;
+GRANT SELECT, INSERT, UPDATE ON ALL TABLES IN SCHEMA <s> TO sigm_app;
+SET ROLE sigm_app;  -- ahora RLS aplica
+```
+NUNCA usar el rol propietario del schema (suele ser superuser) como rol de aplicación.
+
+**UUIDs deterministas en seeds DEBEN usar SOLO chars hex (0-9, a-f)**: la convención común de "prefijo legible" (`vut00000-...` para valores unitarios terreno, `z0000000-...` para zonas, `tv000000-...` para tipos vialidad) produce strings inválidos como UUID. PostgreSQL rechaza con `invalid input syntax for type uuid: "vut00000-..."`. Detectado en sesión 2026-05-04 con 30+ UUIDs inválidos cascadeando errores en seeds dependientes. Fix: usar dígitos hex como prefijo discriminador (`30000000-` zonas, `40000000-` manzanas, `b0000000-` colonias) o usar `gen_random_uuid()` y resolver vínculos via subqueries (`(SELECT id FROM ... WHERE clave = 'X')`).
+
+**Enum types: nunca presumir variantes — consultar `enum_range` antes de seedear**: PostgreSQL crea tipos enum con variantes específicas que pueden diferir del nombre de dominio. Ejemplos reales: `tipo_suelo` no tiene `'rústico'` (con acento) sino `'rural'`; `tipo_estatus_medidor` no tiene `'funcionando'` sino `'funcional'`. Fix: antes de incluir un valor literal en seed o INSERT, ejecutar:
+```sql
+SELECT enum_range(NULL::<schema>.<tipo>);
+-- {funcional,descompuesto,sin_medidor,retirado}
+```
+Si el valor que necesitas no existe, agregar la variante con `ALTER TYPE ... ADD VALUE` en una migración separada — no improvisar en seeds.
+
 **GIN index en columna JSONB no se usa con el operador `->>` en una cláusula WHERE**: `WHERE metadata ->> 'marca' = 'Dell'` extrae texto y compara — este operador no usa el índice GIN. Solo los operadores `@>`, `?`, `?|`, `?&` usan el índice GIN. Causa: `->>` convierte JSONB a texto y la comparación es una operación de texto sin índice JSONB. Fix: para búsquedas de igualdad con índice, usar `WHERE metadata @> '{"marca": "Dell"}'` que sí usa el índice GIN, o crear un índice de expresión B-Tree sobre `(metadata ->> 'marca')`.
 
 **`FORCE ROW LEVEL SECURITY` no protege al usuario dueño de la tabla (superuser/owner)**: el propietario de la tabla y los superusuarios de PostgreSQL bypasean RLS por defecto aunque esté `FORCE` habilitado. Causa: `FORCE` aplica a todos los usuarios excepto al dueño de la tabla y a superusuarios. Fix: si la aplicación conecta como el dueño de la tabla, cambiar el rol de conexión a un rol de aplicación sin privilegios de dueño (`GRANT CONNECT ON DATABASE ... TO app_user`), no usar el usuario `postgres` para conexiones de aplicación.

package/habilidades/verificar-trabajo/SKILL.md

@@ -1,7 +1,12 @@
 ---
 name: verificar-trabajo
 description: Verificación goal-backward del trabajo ejecutado en 4 niveles progresivos — EXISTE, SUSTANTIVO, CONECTADO, DATOS_FLUYEN. Detecta stubs, componentes huérfanos, integraciones rotas y flujos incompletos. Produce veredictos estructurados JSON con clasificación de riesgo (Low/Medium/High) y evidencia verificable. Soporta loop de reparación cuando el veredicto es Fail.
-version: "1.1.0"
+version: "1.1.1"
+evolved: true
+evolved-from: "1.1.0"
+evolved-at: "2026-05-05"
+evolved-by: "aprender"
+evolved-note: "Gotcha de la sesión SIGM 2026-05-05 (L7): tests + linter no detectan schema-seed drift; cuando el alcance toca BD, Nivel 4 obligatorio con docker compose down -v && up fresco"
 herramientasPermitidas: [Read, Write, Edit, Bash, Glob, Grep]
 exclusiones:
   - "No cargar durante la implementación activa de una tarea; la verificación es posterior a la implementación, no concurrente."
@@ -290,6 +295,7 @@ estructurado JSON, ver [recursos/plantilla-verificacion.md](recursos/plantilla-v
 - **Score del veredicto calculado solo sobre artefactos verificados, no sobre todos los prometidos**: si el plan prometía 8 entregables pero solo se verificaron 5, el score 1.0 sobre los 5 no es evidencia de que los 8 están correctos. Causa: el agente omite entregables del plan en la lista de artefactos. Solución: antes de verificar, listar todos los artefactos del PLAN.md y verificar cada uno explícitamente — un artefacto no verificado es un Fail implícito.
 - **Loop de reparación sin re-verificación completa**: tras el fix, el agente re-verifica solo el item que falló en lugar del veredicto completo. Causa: optimización incorrecta para ahorrar tiempo. Solución: el paso 3 del loop de reparación dice explícitamente "re-ejecutar la verificación COMPLETA" — un fix puede resolver un fallo pero introducir otro.
 - **Hollow Component no detectado en Nivel 2**: el componente Angular tiene template pero no usa ninguna señal del componente. El agente verifica que el archivo existe (Nivel 1) y que tiene contenido (Nivel 2), pero no detecta que el contenido es decorativo. Causa: la definición de "stub" en Nivel 2 no se aplicó al caso de templates sin binding. Solución: verificar explícitamente que el template usa al menos una variable/señal del componente.
+- **Verificación con tests + linter pasa pero al levantar BD fresca todo se rompe**: tests Python con mocks y `ruff check` retornan verde, pero `docker compose down -v && up` falla porque hay drift entre `database/schemas/`, seeds, funciones SQL y vistas. Caso real (SIGM 2026-05-04): primera pasada de `/swl:verificar` reportó "APROBADO 21/22" sin detectar que ~10 seeds tenían columnas obsoletas, UUIDs inválidos y un script `02-crear-buckets-minio.sh` que abortaba initdb del contenedor postgres. Causa: la verificación corre solo contra el código (que mockea BD); nunca aplica el SQL real. Solución: cuando el alcance toca cualquier archivo en `database/schemas/`, `database/seeds/`, `database/functions/` o `database/views/`, ejecutar como Nivel 4 (DATOS_FLUYEN) obligatorio: `docker compose down -v && docker compose up -d db && wait_for_health && docker logs <db_container> | grep -E "ERROR|skipped"`. Cualquier ERROR en logs de init invalida el veredicto Pass.
 
 ## Regla de oro del verificador
 

package/hooks/lib/evolution-tracker.js

@@ -72,8 +72,8 @@ function readEvolutionMeta(filePath) {
   try {
     const content = fs.readFileSync(filePath, 'utf8');
 
-    // Detectar frontmatter YAML (entre --- y ---)
-    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    // Detectar frontmatter YAML (entre --- y ---). Soporta LF y CRLF.
+    const fmMatch = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
     if (!fmMatch) {
       // Sin frontmatter — verificar sidecar
       return _readSidecar(filePath);
@@ -120,6 +120,38 @@ function _readSidecar(filePath) {
   return { evolved: false, metadata: {} };
 }
 
+// ---------------------------------------------------------------------------
+// Detección de CWD == package root (commits del mantenedor)
+// ---------------------------------------------------------------------------
+
+/**
+ * Determina si el CWD actual es la raíz del paquete swl-ses.
+ *
+ * Cuando el desarrollador del paquete edita componentes en su propio repo, no
+ * son evoluciones de usuario — son commits normales del mantenedor. Marcar
+ * `evolved: true` en esos casos contamina el frontmatter, ensucia el flujo de
+ * preserve/conflict en upgrades de usuario, y rompe el invariante de que
+ * `evolved: true` significa "este archivo fue modificado por un usuario tras
+ * recibirlo del paquete".
+ *
+ * Heurística: leer `package.json` del cwd; si su campo `name` es
+ * `"@saulwade/swl-ses"` (o `"swl-ses"` legacy), estamos en el repo fuente.
+ *
+ * @param {string} [cwd=process.cwd()]
+ * @returns {boolean}
+ */
+function isPackageRoot(cwd) {
+  const dir = cwd || process.cwd();
+  try {
+    const pkgPath = path.join(dir, 'package.json');
+    if (!fs.existsSync(pkgPath)) return false;
+    const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf8'));
+    return pkg.name === '@saulwade/swl-ses' || pkg.name === 'swl-ses';
+  } catch {
+    return false;
+  }
+}
+
 // ---------------------------------------------------------------------------
 // Escritura de metadata de evolución
 // ---------------------------------------------------------------------------
@@ -127,6 +159,11 @@ function _readSidecar(filePath) {
 /**
  * Marca un archivo como evolucionado inyectando campos en su frontmatter.
  *
+ * Cuando el CWD es la raíz del paquete swl-ses (commit del mantenedor), NO se
+ * inyecta `evolved: true` ni los campos `evolved-*`. El sistema asume que los
+ * cambios en el repo fuente son parte del desarrollo normal, no evoluciones
+ * de usuario.
+ *
  * @param {string} filePath   - Ruta del archivo a marcar.
  * @param {object} meta
  * @param {string} meta.from  - Versión base (ej: "5.1.0").
@@ -134,16 +171,26 @@ function _readSidecar(filePath) {
  * @param {number} [meta.rounds]  - Rondas de autoresearch.
  * @param {string} [meta.score]   - Score "baseline% → final%".
  * @param {string} [meta.note]    - Descripción del cambio.
- * @returns {{ marked: boolean, error?: string }}
+ * @param {boolean} [meta.force]  - Forzar marcado aunque CWD == package root (ej: tests).
+ * @returns {{ marked: boolean, skipped?: boolean, reason?: string, error?: string }}
  */
 function markAsEvolved(filePath, meta) {
   if (!fs.existsSync(filePath)) {
     return { marked: false, error: 'Archivo no existe' };
   }
 
+  if (!meta?.force && isPackageRoot()) {
+    return {
+      marked: false,
+      skipped: true,
+      reason: 'CWD es la raíz del paquete swl-ses — los cambios del mantenedor no se marcan como evolved',
+    };
+  }
+
   try {
     const content = fs.readFileSync(filePath, 'utf8');
-    const fmMatch = content.match(/^(---\n)([\s\S]*?)(\n---)/);
+    // Soportar LF y CRLF en line endings.
+    const fmMatch = content.match(/^(---\r?\n)([\s\S]*?)(\r?\n---)/);
 
     if (!fmMatch) {
       // Sin frontmatter — usar sidecar
@@ -155,11 +202,14 @@ function markAsEvolved(filePath, meta) {
     const suffix = fmMatch[3];
     const rest = content.slice(fmMatch[0].length);
 
+    // Detectar EOL del archivo para preservarlo en la escritura.
+    const eol = prefix.includes('\r\n') ? '\r\n' : '\n';
+
     // Remover campos evolved previos
     frontmatter = frontmatter
-      .split('\n')
+      .split(/\r?\n/)
       .filter(line => !line.match(/^evolved[-\w]*:/))
-      .join('\n');
+      .join(eol);
 
     // Agregar campos nuevos
     const date = new Date().toISOString().split('T')[0];
@@ -173,7 +223,7 @@ function markAsEvolved(filePath, meta) {
     if (meta.score) newFields.push(`evolved-score: "${meta.score}"`);
     if (meta.note) newFields.push(`evolved-note: "${meta.note}"`);
 
-    frontmatter = frontmatter.trimEnd() + '\n' + newFields.join('\n');
+    frontmatter = frontmatter.trimEnd() + eol + newFields.join(eol);
 
     const newContent = prefix + frontmatter + suffix + rest;
     atomicWriteSync(filePath, newContent, 'utf8');
@@ -284,11 +334,13 @@ function decideUpdateStrategy(destino, origen, versionNueva) {
 
 /**
  * Remueve campos de evolución del frontmatter para comparación limpia.
+ * Normaliza CRLF a LF para que el contenido se pueda comparar
+ * independientemente del sistema operativo en que se generó.
  * @private
  */
 function _stripEvolutionFields(content) {
   return content
-    .split('\n')
+    .split(/\r?\n/)
     .filter(line => !line.match(/^evolved[-\w]*:/))
     .join('\n');
 }
@@ -323,10 +375,11 @@ function mergeEvolved(destino, origen, versionNueva) {
     const destinoContent = fs.readFileSync(destino, 'utf8');
     const origenContent  = fs.readFileSync(origen, 'utf8');
 
-    // Extraer las líneas que son diferentes entre destino (sin evolved fields) y origen
+    // Extraer las líneas que son diferentes entre destino (sin evolved fields) y origen.
+    // Normalizar CRLF a LF para comparar independientemente del SO de origen.
     const destinoSinEvo = _stripEvolutionFields(destinoContent);
-    const origenLines    = origenContent.split('\n');
-    const destinoLines   = destinoSinEvo.split('\n');
+    const origenLines    = origenContent.split(/\r?\n/);
+    const destinoLines   = destinoSinEvo.split(/\r?\n/);
 
     const diffs = [];
     const maxLen = Math.max(origenLines.length, destinoLines.length);
@@ -445,6 +498,7 @@ module.exports = {
   decideUpdateStrategy,
   mergeEvolved,
   scanEvolved,
+  isPackageRoot,
   EVOLUTION_FIELDS,
   EVOLUTION_SOURCES,
   SIDECAR_FILENAME,

package/hooks/lib/memory-search.js

@@ -25,6 +25,16 @@ const path = require('path');
 
 const sessionFts = require('./session-fts');
 
+// RRF fusion para combinar streams heterogéneos. Carga defensiva: si la lib no
+// está disponible (ej. instalación parcial), `search()` cae al merge por
+// relevancia simple — backward compatible.
+let rrfFusion = null;
+try {
+  ({ rrfFusion } = require('../../scripts/lib/rrf-fusion'));
+} catch (_) {
+  rrfFusion = null;
+}
+
 // ---------------------------------------------------------------------------
 // Constantes
 // ---------------------------------------------------------------------------
@@ -321,16 +331,39 @@ function search(baseDir, query, filtros = {}) {
     ? filtros.limit
     : 20;
 
-  let resultados = [];
-
-  if (!filtros.tipo || filtros.tipo === 'aprendizaje') {
-    resultados.push(...buscarEnAprendizajes(baseDir, terminos));
-  }
-  if (!filtros.tipo || filtros.tipo === 'sesion') {
-    resultados.push(...buscarEnSesiones(baseDir, terminos));
-  }
-  if (!filtros.tipo || filtros.tipo === 'instinto') {
-    resultados.push(...buscarEnInstintos(baseDir, terminos));
+  // Cada fuente devuelve sus resultados ordenados por relevancia interna.
+  // Conservamos los streams separados para que RRF los combine usando rank,
+  // no la magnitud de la relevancia (que no es comparable entre fuentes).
+  const stream_aprendizajes = (!filtros.tipo || filtros.tipo === 'aprendizaje')
+    ? buscarEnAprendizajes(baseDir, terminos).sort((a, b) => b.relevancia - a.relevancia)
+    : [];
+  const stream_sesiones = (!filtros.tipo || filtros.tipo === 'sesion')
+    ? buscarEnSesiones(baseDir, terminos).sort((a, b) => b.relevancia - a.relevancia)
+    : [];
+  const stream_instintos = (!filtros.tipo || filtros.tipo === 'instinto')
+    ? buscarEnInstintos(baseDir, terminos).sort((a, b) => b.relevancia - a.relevancia)
+    : [];
+
+  let resultados;
+
+  if (rrfFusion && (stream_aprendizajes.length + stream_sesiones.length + stream_instintos.length) > 0) {
+    // RRF fusion: combina streams heterogéneos usando posición (rank), no
+    // magnitud de relevancia. Los pesos reflejan la utilidad relativa
+    // observada empíricamente:
+    //   - Aprendizajes (0.4): conocimiento curado, mayor señal por entrada.
+    //   - Sesiones (0.4): contexto operativo, alta densidad pero ruidoso.
+    //   - Instintos (0.2): patrones consolidados, pocos pero específicos.
+    resultados = rrfFusion(
+      [stream_aprendizajes, stream_sesiones, stream_instintos],
+      { weights: [0.4, 0.4, 0.2] },
+    );
+  } else {
+    // Fallback sin RRF: merge por relevancia simple (comportamiento legado).
+    resultados = [
+      ...stream_aprendizajes,
+      ...stream_sesiones,
+      ...stream_instintos,
+    ].sort((a, b) => b.relevancia - a.relevancia);
   }
 
   // Filtros de fecha (solo sobre resultados con fecha real)
@@ -345,9 +378,7 @@ function search(baseDir, query, filtros = {}) {
     );
   }
 
-  return resultados
-    .sort((a, b) => b.relevancia - a.relevancia)
-    .slice(0, limit);
+  return resultados.slice(0, limit);
 }
 
 // ---------------------------------------------------------------------------

package/hooks/sugerir-contribuir.js

@@ -0,0 +1,226 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: sugerir-contribuir.js
+ * Tipo: PostToolUse  (aplica a: Write, Edit, MultiEdit)
+ *
+ * Cuando el usuario edita un componente con frontmatter `evolved: true` en su
+ * instalación de SWL (no en el repo fuente), sugiere — sin bloquear — abrir
+ * `/swl:contribuir <skill>` para subir la mejora al core via PR.
+ *
+ * Origen: durante v1.2.0 detectamos que las evoluciones locales quedaban
+ * atrapadas en una sola máquina porque `markAsEvolved` marca pero no notifica.
+ * Sin canal de "subida", una mejora de un usuario nunca llega al paquete y se
+ * pierde para todos los demás equipos. Este nudge cierra ese ciclo.
+ *
+ * Reglas de activación:
+ *   - El archivo está en agentes/, habilidades/, comandos/swl/ o reglas/
+ *   - El archivo tiene `evolved: true` en frontmatter (o sidecar .evolved.json)
+ *   - El CWD NO es la raíz del paquete swl-ses (un mantenedor editando el
+ *     repo fuente NO debe recibir el nudge — sus cambios van por PR normal)
+ *   - No estamos dentro del cooldown de 24h para este archivo
+ *
+ * Cooldown: 24h por archivo. Estado en
+ * `.planning/comms/sugerir-contribuir-cooldown.json`.
+ *
+ * Resultado:
+ *   - Cumple condiciones → sugerencia en stdout (exit 0)
+ *   - No cumple          → sin output (exit 0)
+ *   - Error interno      → sin output (nunca bloquear)
+ *
+ * Activo por defecto. Para silenciar: SWL_SUGERIR_CONTRIBUIR=0.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+let isPackageRoot, readEvolutionMeta;
+try {
+  ({ isPackageRoot, readEvolutionMeta } = require('./lib/evolution-tracker'));
+} catch {
+  // Fallback si el módulo no carga: nunca bloquear, no emitir
+  isPackageRoot = () => false;
+  readEvolutionMeta = () => ({ evolved: false, metadata: {} });
+}
+
+const CARPETAS_EVOLUCIONABLES = [
+  'agentes/',
+  'habilidades/',
+  'comandos/swl/',
+  'reglas/',
+];
+
+const STATE_FILE = path.join(
+  process.cwd(),
+  '.planning',
+  'comms',
+  'sugerir-contribuir-cooldown.json'
+);
+const COOLDOWN_MS = 24 * 60 * 60 * 1000; // 24h
+
+function normalizarSeparadores(p) {
+  return String(p).replace(/\\/g, '/');
+}
+
+function rutaRelativaAlProyecto(rutaRaw) {
+  if (!rutaRaw) return null;
+  let normalizada = normalizarSeparadores(rutaRaw);
+
+  if (path.isAbsolute(normalizada)) {
+    const cwd = normalizarSeparadores(process.cwd());
+    if (normalizada.toLowerCase().startsWith(cwd.toLowerCase())) {
+      normalizada = normalizada.slice(cwd.length).replace(/^\/+/, '');
+    } else {
+      return null;
+    }
+  } else {
+    normalizada = normalizada.replace(/^\.\//, '');
+  }
+
+  return normalizada;
+}
+
+function esEvolucionable(rutaRelativa) {
+  if (!rutaRelativa) return false;
+  if (!rutaRelativa.endsWith('.md')) return false;
+  return CARPETAS_EVOLUCIONABLES.some(c => rutaRelativa.startsWith(c));
+}
+
+function nombreSkillDesdeRuta(rutaRelativa) {
+  // habilidades/postgresql-experto/SKILL.md → postgresql-experto
+  // agentes/orquestador-swl.md              → orquestador-swl
+  // comandos/swl/release.md                  → /swl:release
+  // reglas/seguridad.md                      → reglas/seguridad
+  if (rutaRelativa.startsWith('habilidades/')) {
+    const rest = rutaRelativa.slice('habilidades/'.length);
+    return rest.split('/')[0];
+  }
+  if (rutaRelativa.startsWith('agentes/')) {
+    return path.basename(rutaRelativa, '.md');
+  }
+  if (rutaRelativa.startsWith('comandos/swl/')) {
+    return '/swl:' + path.basename(rutaRelativa, '.md');
+  }
+  if (rutaRelativa.startsWith('reglas/')) {
+    return rutaRelativa.replace(/\.md$/, '');
+  }
+  return path.basename(rutaRelativa, '.md');
+}
+
+function leerEstado() {
+  try {
+    return JSON.parse(fs.readFileSync(STATE_FILE, 'utf8'));
+  } catch {
+    return {};
+  }
+}
+
+function escribirEstado(estado) {
+  try {
+    fs.mkdirSync(path.dirname(STATE_FILE), { recursive: true });
+    const tmp = STATE_FILE + '.tmp';
+    fs.writeFileSync(tmp, JSON.stringify(estado, null, 2), 'utf8');
+    fs.renameSync(tmp, STATE_FILE);
+  } catch {
+    // Falla silenciosa — cooldown no es crítico
+  }
+}
+
+function dentroDeCooldown(estado, ruta) {
+  const ultima = estado[ruta];
+  if (!ultima) return false;
+  return Date.now() - ultima < COOLDOWN_MS;
+}
+
+function marcarAviso(estado, ruta) {
+  estado[ruta] = Date.now();
+  escribirEstado(estado);
+}
+
+function construirMensaje(rutaRelativa, metadata) {
+  const skill = nombreSkillDesdeRuta(rutaRelativa);
+  const desde = metadata.evolvedFrom || '?';
+  const por = metadata.evolvedBy || 'auto-evolución';
+  const nota = metadata.evolvedNote ? `\n   Nota: ${metadata.evolvedNote}` : '';
+
+  return (
+    '\n[swl-ses] Detecté una evolución local en `' + rutaRelativa + '` ' +
+    '(desde v' + desde + ' por ' + por + ').' + nota + '\n' +
+    '   Si la mejora aplica a ingeniería de software general, considera contribuirla:\n' +
+    '     /swl:contribuir ' + skill + '\n' +
+    '   Eso valida con PluginEval (≥80) y abre PR al core para que otros equipos\n' +
+    '   reciban el cambio en el siguiente release.\n' +
+    '   (silenciar con SWL_SUGERIR_CONTRIBUIR=0; cooldown 24h por archivo)\n'
+  );
+}
+
+function extraerRuta(toolInput) {
+  if (!toolInput || typeof toolInput !== 'object') return null;
+  return (
+    toolInput.file_path ||
+    toolInput.path ||
+    toolInput.notebook_path ||
+    null
+  );
+}
+
+function evaluar(toolName, toolInput) {
+  if (!['Write', 'Edit', 'MultiEdit'].includes(toolName)) return null;
+  if (isPackageRoot()) return null; // Mantenedor editando el repo: nunca sugerir
+
+  const rutaRaw = extraerRuta(toolInput);
+  const ruta = rutaRelativaAlProyecto(rutaRaw);
+  if (!ruta) return null;
+  if (!esEvolucionable(ruta)) return null;
+
+  const rutaAbsoluta = path.isAbsolute(rutaRaw) ? rutaRaw : path.join(process.cwd(), ruta);
+  if (!fs.existsSync(rutaAbsoluta)) return null;
+
+  const evo = readEvolutionMeta(rutaAbsoluta);
+  if (!evo.evolved) return null;
+
+  return { ruta, metadata: evo.metadata };
+}
+
+function ejecutarComoHook() {
+  let inputRaw = '';
+
+  process.stdin.on('data', chunk => { inputRaw += chunk; });
+
+  process.stdin.on('end', () => {
+    try {
+      if (process.env.SWL_SUGERIR_CONTRIBUIR === '0') return;
+
+      const data = JSON.parse(inputRaw || '{}');
+      const toolName = String(data.tool_name || data.tool?.name || '');
+      const toolInput = data.tool_input || data.tool?.input || {};
+
+      const r = evaluar(toolName, toolInput);
+      if (!r) return;
+
+      const estado = leerEstado();
+      if (dentroDeCooldown(estado, r.ruta)) return;
+
+      process.stdout.write(construirMensaje(r.ruta, r.metadata));
+      marcarAviso(estado, r.ruta);
+    } catch {
+      // Errores internos nunca bloquean
+    }
+  });
+}
+
+if (require.main === module) {
+  ejecutarComoHook();
+}
+
+module.exports = {
+  CARPETAS_EVOLUCIONABLES,
+  COOLDOWN_MS,
+  rutaRelativaAlProyecto,
+  esEvolucionable,
+  nombreSkillDesdeRuta,
+  dentroDeCooldown,
+  construirMensaje,
+  evaluar,
+};

package/manifiestos/hooks-config.json

@@ -99,6 +99,15 @@
       "maxConsecutiveFailures": 5,
       "degradeOnFailure": "skip"
     },
+    "sugerir-contribuir.js": {
+      "event": "PostToolUse",
+      "matcher": "Write|Edit|MultiEdit",
+      "description": "Cuando el usuario edita un componente con frontmatter `evolved: true` en su instalación (no en el repo fuente), sugiere abrir /swl:contribuir para subir la mejora al core. Cooldown 24h por archivo. Activo por defecto; silenciar con SWL_SUGERIR_CONTRIBUIR=0.",
+      "blocking": false,
+      "async": true,
+      "maxConsecutiveFailures": 5,
+      "degradeOnFailure": "skip"
+    },
     "degradacion-instintos.js": {
       "event": "PostToolUse",
       "matcher": "Bash|Write|Edit",

package/manifiestos/modulos.json

@@ -727,6 +727,8 @@
         "habilidades/brainstorming",
         "habilidades/context-builder",
         "habilidades/memoria-busqueda",
+        "habilidades/eval-framework",
+        "habilidades/benchmark-memoria",
         "habilidades/prevencion-racionalizacion",
         "habilidades/prevencion-sobreingenieria",
         "habilidades/privacy-memoria",
@@ -954,6 +956,7 @@
         "hooks/inbox-aviso.js",
         "hooks/aiisms-detector.js",
         "hooks/sugerir-regenerar-inventario.js",
+        "hooks/sugerir-contribuir.js",
         "hooks/_run-hook.sh",
         "hooks/lib/fingerprint-id.js",
         "hooks/lib/token-budget.js",
@@ -1001,7 +1004,19 @@
         "scripts/lib/scoring-instintos.js",
         "scripts/lib/budget-enforcer.js",
         "scripts/lib/semantic-search.js",
-        "scripts/lib/diary-entry.js"
+        "scripts/lib/diary-entry.js",
+        "scripts/lib/rrf-fusion.js",
+        "scripts/lib/jaccard-similarity.js",
+        "scripts/detectar-aprendizajes-duplicados.js",
+        "scripts/lib/eval-schemas.js",
+        "scripts/lib/eval-validator.js",
+        "scripts/lib/eval-quality.js",
+        "scripts/lib/eval-self-correct.js",
+        "scripts/lib/eval-metrics-store.js",
+        "scripts/run-eval.js",
+        "scripts/lib/benchmark-metrics.js",
+        "scripts/lib/longmemeval-runner.js",
+        "scripts/benchmark-memoria.js"
       ],
       "targets": [
         "claude",
@@ -1120,6 +1135,23 @@
         "gemini"
       ]
     },
+    "mcp-server-swl": {
+      "descripcion": "MCP server stub experimental que expone memoria SWL (aprendizajes, sesiones, instintos) a clientes MCP externos (Cursor, Gemini CLI, OpenCode, Cline, Claude Desktop). Modo stdio. 3 endpoints: swl_memory_search, swl_aprendizajes_recientes, swl_instintos_activos. SIN auth, SIN rate limiting, SIN HTTP transport, SIN tests integración. NO USAR EN PRODUCCIÓN. Trigger para hardening: uso real ≥2 runtimes diferentes consistentemente por ≥1 mes. El binario `swl-mcp-server` se instala automáticamente vía npm install -g (declarado en package.json bin). NO se propaga al runtime SWL — vive en el paquete npm como herramienta opt-in. Ver scripts/mcp-server/README.md para 11 limitaciones explícitas y diseño futuro.",
+      "tipo": "scripts",
+      "archivos": [
+        "bin/swl-mcp-server.js",
+        "scripts/mcp-server/handlers.js",
+        "scripts/mcp-server/README.md"
+      ],
+      "targets": [
+        "claude",
+        "openclaude",
+        "copilot",
+        "opencode",
+        "codex",
+        "gemini"
+      ]
+    },
     "rotacion-audit": {
       "descripcion": "Rotación de logs de auditoría (.planning/audit.jsonl y audit-merkle.jsonl) a archivos .gz mensuales en .planning/archivo/audit/. Política por defecto: entradas con timestamp mayor a 30 días se archivan. Zero-deps (fs/zlib/path), CRLF-safe, preserva cadena Merkle. Ejecución automática vía hook Stop 'rotar-audit-auto.js' cuando algún audit*.jsonl supera 5 MB (cooldown 6h). Ejecución manual vía 'node scripts/rotar-audit-logs.js' con --dry-run/--dias=N opcionales. Desactivable con SWL_AUDIT_ROTATE_OFF=1.",
       "tipo": "scripts",

package/manifiestos/perfiles.json

@@ -397,7 +397,8 @@
         "hooks-observabilidad",
         "hooks-multica",
         "graphify-swl",
-        "mcp-swl"
+        "mcp-swl",
+        "mcp-server-swl"
       ]
     }
   }

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@saulwade/swl-ses",
-  "version": "1.1.4",
-  "description": "Sistema de ingenieria de software auto-evolutivo multi-runtime polyglot con 59 agentes, 151 habilidades, 42 comandos, 64 reglas y 39 hooks. Soporta 11 lenguajes y 5 runtimes: Claude Code, Copilot, OpenCode, Codex y Gemini CLI. 100% en espanol (Mexico). Incluye gateway bidireccional con relay Telegram a Claude Code.",
+  "version": "1.2.0",
+  "description": "Sistema de ingenieria de software auto-evolutivo multi-runtime polyglot con 59 agentes, 151 habilidades, 42 comandos, 64 reglas y 40 hooks. Soporta 11 lenguajes y 5 runtimes: Claude Code, Copilot, OpenCode, Codex y Gemini CLI. 100% en espanol (Mexico). Incluye gateway bidireccional con relay Telegram a Claude Code.",
   "bin": {
     "swl-ses": "bin/swl-ses.js",
-    "swl-telegram-bot": "bin/swl-telegram-bot.js"
+    "swl-telegram-bot": "bin/swl-telegram-bot.js",
+    "swl-mcp-server": "bin/swl-mcp-server.js"
   },
   "files": [
     "bin",