@saulwade/swl-ses 2.0.0 → 2.1.0

package/habilidades/validacion-ci-sistema/SKILL.md

@@ -1,7 +1,7 @@
 ---
 name: validacion-ci-sistema
 description: Validación de integridad del sistema SWL inspirado en ECC CI stack. Cubre validación de frontmatter de agentes, validación de skills (SKILL.md presente y no vacío), validación de hooks (sintaxis Node.js, exit codes), validación de comandos, validación de reglas, catálogo automático con métricas y script ejecutable de validación.
-version: "1.0.0"
+version: "1.1.0"
 herramientasPermitidas: [Read, Bash]
 exclusiones:
   - "No cargar para validar el código de aplicación del usuario (tests, linting de Python/TS, cobertura) — este skill valida la integridad del sistema SWL (frontmatter de agentes, SKILL.md presentes, exit codes de hooks); para validación de código cargar `reglas/pruebas.md` o invocar `tdd-qa-swl`."
@@ -20,6 +20,22 @@ El sistema SWL crece con el tiempo. Sin validación, acumula:
 - Hooks que fallan con códigos de salida incorrectos
 - Comandos con formato inválido
 
+## Precondición — solo aplica al repo host de SWL
+
+Este skill valida los **componentes** del sistema SWL (`agentes/`, `habilidades/`,
+`comandos/swl/`, `reglas/`, `hooks/`). Solo tiene sentido en el repo que los
+**hospeda** (swl-ses o un fork). En un proyecto **consumidor** (usa las
+convenciones SWL vía `~/.claude/` pero no aloja los componentes), no hay nada que
+validar y un score de componentes sería engañoso. El gate determinista vive en
+`/swl:status salud` (Paso 0):
+
+```bash
+node scripts/lib/detectar-host-swl.js --json
+```
+
+Si `esHost: false`, NO ejecutar este skill: reportar que `salud` no aplica y
+redirigir a los subcomandos de `/swl:status` que sí aplican al proyecto consumidor.
+
 ---
 
 ## Reglas de Validación por Componente

package/hooks/calidad-pre-commit.js

@@ -911,7 +911,11 @@ function extraerMensajeCommit(comando) {
  * @returns {boolean}
  */
 function esPrefijoExentoDeTests(mensaje) {
-  return /^\s*(docs|chore|style)(\([^)]*\))?!?:/i.test(mensaje);
+  // Tolera prefijo(s) de trazabilidad de `ejecutar-fase` antes del tipo CC:
+  // `[T-NN]`, `[REQ-NN]`, `[F<fase>·T-NN]` (uno o más, consecutivos). Desde la
+  // Fase 12 los IDs se namespacean por fase (DT-IDS-NAMESPACE). El prefijo no
+  // cambia la semántica: un `[F12·T-03] docs(...)` sigue siendo exento de tests.
+  return /^\s*(?:\[(?:F\d+·)?(?:T|REQ)-\d+(?:-\d+)?\]\s*)*(docs|chore|style)(\([^)]*\))?!?:/i.test(mensaje);
 }
 
 /**

package/hooks/check-update.js

@@ -22,7 +22,22 @@ const fs   = require('fs');
 const path = require('path');
 const os   = require('os');
 
-const { compararSemver, versionRemotaParalela } = require('../scripts/lib/npm-version');
+// La lib npm-version se distribuye junto con el hook (modulos.json hooks-core).
+// Require tolerante: repo madre / destino copy (../scripts/lib), destino
+// aplanado (./lib), o null. Antes de v2.2 este require era directo y la lib NO
+// se distribuía: en TODA instalación destino el hook moría con MODULE_NOT_FOUND
+// que el wrapper de settings.json traga en silencio — el aviso de nuevas
+// versiones nunca llegó a otros equipos (reportado 2026-06-12). Sin la lib, el
+// hook emite un diagnóstico throttled en vez de callar (anti-fallback-silencioso).
+let compararSemver = null;
+let versionRemotaParalela = null;
+try {
+  ({ compararSemver, versionRemotaParalela } = require('../scripts/lib/npm-version'));
+} catch (_) {
+  try {
+    ({ compararSemver, versionRemotaParalela } = require('./lib/npm-version'));
+  } catch (_2) { /* null — diagnosticado en el entrypoint */ }
+}
 
 // ---------------------------------------------------------------------------
 // Constantes
@@ -176,6 +191,29 @@ process.stdin.on('data', chunk => { inputRaw += chunk; });
 
 process.stdin.on('end', async () => {
   try {
+    // Lib no disponible (instalación incompleta o versión previa al fix de
+    // distribución): avisar una vez por ventana de throttle en vez de morir
+    // en silencio. `remota` con sentinel truthy → ventana de 24h, no de 1h.
+    if (!versionRemotaParalela || !compararSemver) {
+      if (debeVerificar()) {
+        try {
+          fs.writeFileSync(flagPath(), JSON.stringify({
+            timestamp: Date.now(),
+            local: null,
+            remota: 'lib-no-disponible',
+            hayNueva: false,
+            notificado: 2,
+          }), 'utf8');
+        } catch { /* silencioso */ }
+        process.stderr.write(
+          '[swl-ses/check-update] lib npm-version no disponible — el aviso de ' +
+          'nuevas versiones está inactivo. Reinstala con: ' +
+          'npx -y @saulwade/swl-ses@latest update\n'
+        );
+      }
+      return;
+    }
+
     // Throttle: solo verificar cada 24h
     if (!debeVerificar()) {
       // Si el último check detectó actualización, repetir notificación (1 vez)

package/hooks/lib/autonomia.js

@@ -0,0 +1,208 @@
+'use strict';
+
+/**
+ * hooks/lib/autonomia.js — Fase 13 (ADR-0037): presupuesto de autonomía.
+ *
+ * Carga el dial de autonomía por clase de riesgo desde instintos/autonomia.yaml
+ * y provee el auto-checkpoint mecánico que precede a una acción autónoma de clase
+ * cambio_reversible (reversibilidad como precondición de autonomía, D-13-05).
+ *
+ * Defaults = los controles vigentes de reglas/seguridad-agentes.md. La lib NUNCA
+ * relaja: valores desconocidos o clases ausentes degradan al default (más
+ * restrictivo). Si el yaml no existe (proyecto destino sin el archivo), usa
+ * DEFAULTS hardcodeados.
+ *
+ * Enforcement v1 = GUÍA leída + auto-checkpoint mecánico. NO es un gate bloqueante
+ * (eso es el patrón que el ADR descartó). El test de REQ-13-07 verifica el
+ * mecanismo del checkpoint, no la conducta del agente.
+ *
+ * Zero-deps (Node stdlib). Parser YAML local mínimo: la estructura de
+ * autonomia.yaml es plana y trivial, así se evita el require cross-dir
+ * hooks/lib → scripts/lib que se rompe en el destino aplanado.
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+// Defaults = reglas/seguridad-agentes.md (este archivo NO los relaja).
+const DEFAULTS = Object.freeze({
+  lectura_analisis: 'total',
+  cambio_reversible: 'con_auto_checkpoint',
+  migracion_auth_push_publish: 'hitl',
+});
+
+// Nivel válido por clase. Cualquier otro valor degrada a 'hitl'.
+const NIVELES_VALIDOS = new Set(['total', 'con_auto_checkpoint', 'hitl']);
+
+const YAML_PATH = ['instintos', 'autonomia.yaml'];
+const CHECKPOINTS_PATH = ['.planning', 'user-profile', 'auto-checkpoints.jsonl'];
+
+/**
+ * Parser mínimo de la estructura plana de autonomia.yaml:
+ *   key: value           (escalares de primer nivel)
+ *   clases:
+ *     subkey: value      (1 nivel de anidamiento)
+ * Ignora comentarios (#) y líneas en blanco. Suficiente para este archivo.
+ */
+// Claves prohibidas: evitan prototype pollution si un yaml hostil las declara.
+const CLAVES_PROHIBIDAS = new Set(['__proto__', 'constructor', 'prototype']);
+
+function _parsearYamlPlano(texto) {
+  const out = {};
+  let seccion = null;
+  for (const lineaRaw of String(texto).split(/\r?\n/)) {
+    const linea = lineaRaw.replace(/\s+#.*$/, ''); // comentario inline
+    if (!linea.trim() || linea.trim().startsWith('#')) continue;
+    const mSeccion = linea.match(/^([A-Za-z_][\w-]*)\s*:\s*$/);
+    if (mSeccion) {
+      seccion = mSeccion[1];
+      if (CLAVES_PROHIBIDAS.has(seccion)) { seccion = null; continue; }
+      out[seccion] = {};
+      continue;
+    }
+    const mKV = linea.match(/^(\s*)([A-Za-z_][\w-]*)\s*:\s*(.+?)\s*$/);
+    if (mKV) {
+      const indent = mKV[1].length;
+      const k = mKV[2];
+      if (CLAVES_PROHIBIDAS.has(k)) continue;
+      const v = mKV[3].replace(/^["'](.*)["']$/, '$1');
+      if (indent > 0 && seccion) {
+        out[seccion][k] = v;
+      } else {
+        seccion = null;
+        out[k] = v;
+      }
+    }
+  }
+  return out;
+}
+
+function _normalizarNivel(valor) {
+  return NIVELES_VALIDOS.has(valor) ? valor : 'hitl';
+}
+
+/**
+ * Carga el dial de autonomía. Merge que solo COMPLETA con defaults y degrada
+ * valores desconocidos a 'hitl' (nunca relaja).
+ * @param {string} baseDir - raíz del proyecto (default: cwd).
+ * @returns {{version?:string, defaults?:string, clases:Object}}
+ */
+function cargarDial(baseDir) {
+  const ruta = path.join(baseDir || process.cwd(), ...YAML_PATH);
+  let parsed = {};
+  try {
+    parsed = _parsearYamlPlano(fs.readFileSync(ruta, 'utf8'));
+  } catch (_) {
+    parsed = {}; // sin archivo → solo defaults
+  }
+  const clasesYaml = parsed.clases && typeof parsed.clases === 'object' ? parsed.clases : {};
+  const clases = {};
+  for (const clase of Object.keys(DEFAULTS)) {
+    clases[clase] = clase in clasesYaml ? _normalizarNivel(clasesYaml[clase]) : DEFAULTS[clase];
+  }
+  return {
+    version: parsed.version,
+    defaults: parsed.defaults || 'seguridad-agentes.md',
+    clases,
+  };
+}
+
+/**
+ * ¿La clase requiere auto-checkpoint antes de actuar autónomamente?
+ * Solo cuando el dial declara la clase como 'con_auto_checkpoint'.
+ * @param {object} dial
+ * @param {string} clase
+ * @returns {boolean}
+ */
+function requiereAutoCheckpoint(dial, clase) {
+  return !!(dial && dial.clases && dial.clases[clase] === 'con_auto_checkpoint');
+}
+
+function _gitHead(baseDir) {
+  try {
+    return execFileSync('git', ['rev-parse', 'HEAD'], {
+      cwd: baseDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim() || null;
+  } catch (_) {
+    return null;
+  }
+}
+
+function _archivosModificados(baseDir) {
+  try {
+    return execFileSync('git', ['status', '--porcelain'], {
+      cwd: baseDir, encoding: 'utf8', stdio: ['ignore', 'pipe', 'ignore'],
+    })
+      .split('\n').map((l) => l.slice(3).trim()).filter(Boolean);
+  } catch (_) {
+    return [];
+  }
+}
+
+/**
+ * Registra un auto-checkpoint antes de una acción autónoma de cambio reversible.
+ * No hace snapshot: los commits atómicos SON la reversibilidad (seguridad-agentes.md);
+ * el checkpoint registra HEAD + archivos modificados como evidencia de rollback.
+ * Best-effort: nunca lanza (no debe bloquear la acción que protege).
+ * @param {string} baseDir
+ * @param {string} accion - descripción corta de la acción.
+ * @param {string} [tsISO] - timestamp inyectable para tests.
+ * @returns {{ts,accion,clase,gitHead,archivosModificados}}
+ */
+const MAX_ACCION_LEN = 512; // tope para que el JSONL no crezca sin límite
+
+function autoCheckpoint(baseDir, accion, tsISO) {
+  const base = baseDir || process.cwd();
+  const registro = {
+    ts: tsISO || new Date().toISOString(),
+    accion: String(accion || '').slice(0, MAX_ACCION_LEN),
+    clase: 'cambio_reversible',
+    gitHead: _gitHead(base),
+    archivosModificados: _archivosModificados(base),
+  };
+  try {
+    const ruta = path.join(base, ...CHECKPOINTS_PATH);
+    const dir = path.dirname(ruta);
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    fs.appendFileSync(ruta, JSON.stringify(registro) + '\n');
+  } catch (_) {
+    // persistir es best-effort; el registro se devuelve igual.
+  }
+  return registro;
+}
+
+// ─── CLI ──────────────────────────────────────────────────────────────────────
+
+// Soporta `--accion=texto` y `--accion texto`. Un solo mecanismo de parse.
+function _parseAccion(args) {
+  for (let j = 0; j < args.length; j++) {
+    const a = args[j];
+    if (a.startsWith('--accion=')) return a.slice('--accion='.length);
+    if (a === '--accion' && args[j + 1] && !args[j + 1].startsWith('--')) return args[j + 1];
+  }
+  return '';
+}
+
+function main(argv) {
+  const accion = _parseAccion(argv.slice(2));
+  const baseDir = process.cwd();
+  const dial = cargarDial(baseDir);
+  if (requiereAutoCheckpoint(dial, 'cambio_reversible')) {
+    const reg = autoCheckpoint(baseDir, accion || '(sin descripción)');
+    process.stdout.write(JSON.stringify(reg) + '\n');
+  }
+  return 0;
+}
+
+if (require.main === module) {
+  process.exit(main(process.argv));
+}
+
+module.exports = {
+  DEFAULTS,
+  cargarDial,
+  requiereAutoCheckpoint,
+  autoCheckpoint,
+  _parsearYamlPlano,
+};