@saulwade/swl-ses 1.0.0 → 1.1.1

package/scripts/generar-inventario.js

@@ -20,6 +20,15 @@ const fs   = require('fs');
 const path = require('path');
 
 const RAIZ = path.resolve(__dirname, '..');
+
+// Escritura atómica obligatoria (regla CLAUDE.md). INVENTARIO.md y SALUD.md
+// son artefactos de release; corrupción durante regeneración rompe la gate.
+let atomicWriteSync;
+try {
+  ({ atomicWriteSync } = require(path.join(RAIZ, 'hooks', 'lib', 'atomic-write.js')));
+} catch {
+  atomicWriteSync = (p, c, e) => fs.writeFileSync(p, c, e);
+}
 const args = new Set(process.argv.slice(2));
 const DRY  = args.has('--dry-run');
 const SOLO_INV = args.has('--inventario');
@@ -206,6 +215,62 @@ function generarInventario() {
 
 // ── Generar SALUD.md ──────────────────────────────────────────────────
 
+/**
+ * Componentes críticos del sistema cuya conducta debe estar verificada con
+ * tests/evals para que el score conductual no sea opaco.
+ *
+ * Cada entrada lista los keywords que matchean nombres de archivos en tests/
+ * o evals/. Si al menos un archivo coincide, el componente tiene cobertura
+ * conductual mínima.
+ */
+const COMPONENTES_CRITICOS = [
+  { id: 'orquestador',     keywords: ['orquestador', 'orquestacion'] },
+  { id: 'auto-evolucion',  keywords: ['auto-evolucion', 'auto-evolution'] },
+  { id: 'red-team',        keywords: ['red-team', 'redteam'] },
+  { id: 'risk-scoring',    keywords: ['risk-scoring', 'risk_scoring', 'risk-engine'] },
+  { id: 'memory-search',   keywords: ['memory-search', 'memoria-busqueda'] },
+  { id: 'command-relay',   keywords: ['command-relay', 'gateway'] },
+  { id: 'privacy-filter',  keywords: ['privacy', 'privacy-filter', 'privacy-memoria'] },
+  { id: 'delegation',      keywords: ['delegation', 'delegacion'] },
+];
+
+/**
+ * Calcula cobertura conductual: cuántos componentes críticos tienen ≥1 archivo
+ * de test o eval. NO mide calidad de los tests — solo presencia mínima.
+ */
+function calcularScoreConductual() {
+  const todosTests = [];
+  const walk = (dir) => {
+    let entries;
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); }
+    catch { return; }
+    for (const e of entries) {
+      const full = path.join(dir, e.name);
+      if (e.isDirectory()) walk(full);
+      else todosTests.push(full.toLowerCase());
+    }
+  };
+  walk(path.join(RAIZ, 'tests'));
+  // También considerar evals dentro de habilidades/*/evals/
+  walk(path.join(RAIZ, 'habilidades'));
+
+  const cobertura = COMPONENTES_CRITICOS.map(c => {
+    const cubierto = todosTests.some(t =>
+      c.keywords.some(k => t.includes(k.toLowerCase()))
+    );
+    return { id: c.id, cubierto };
+  });
+
+  const cubiertos = cobertura.filter(c => c.cubierto).length;
+  const total = cobertura.length;
+  return {
+    cubiertos,
+    total,
+    porcentaje: Math.round((cubiertos / total) * 100),
+    detalle: cobertura,
+  };
+}
+
 function generarSalud() {
   const pkg = JSON.parse(fs.readFileSync(path.join(RAIZ, 'package.json'), 'utf8'));
   const plugin = JSON.parse(fs.readFileSync(path.join(RAIZ, 'plugin.json'), 'utf8'));
@@ -233,14 +298,24 @@ function generarSalud() {
   // Verificar versiones
   const versionConsistente = pkg.version === plugin.version;
 
-  // Problemas
+  // Problemas estructurales
   const problemas = [];
   if (!versionConsistente) problemas.push(`Versiones inconsistentes: package.json=${pkg.version} plugin.json=${plugin.version}`);
   if (hookSyntax.fail > 0) problemas.push(`${hookSyntax.fail} hooks con error de sintaxis`);
   if (libSyntax.fail > 0) problemas.push(`${libSyntax.fail} libs con error de sintaxis`);
 
-  const score = problemas.length === 0 ? '100%' : `${Math.round((1 - problemas.length / 10) * 100)}%`;
-  const estado = problemas.length === 0 ? 'Excelente' : 'Con problemas';
+  const scoreEstructural = problemas.length === 0
+    ? '100%'
+    : `${Math.round((1 - problemas.length / 10) * 100)}%`;
+  const estadoEstructural = problemas.length === 0 ? 'Excelente' : 'Con problemas';
+
+  // Score conductual (cobertura mínima por componente crítico)
+  const conductual = calcularScoreConductual();
+  let estadoConductual;
+  if (conductual.porcentaje >= 80)      estadoConductual = 'Excelente';
+  else if (conductual.porcentaje >= 50) estadoConductual = 'Aceptable';
+  else if (conductual.porcentaje >= 20) estadoConductual = 'Insuficiente';
+  else                                   estadoConductual = 'Crítico';
 
   const lines = [];
   lines.push('# Reporte de Salud del Sistema SWL');
@@ -251,7 +326,19 @@ function generarSalud() {
   lines.push('> Archivo generado automáticamente por `node scripts/generar-inventario.js --salud`.');
   lines.push('> NO editar manualmente — se regenera con cada release.');
   lines.push('');
-  lines.push(`## Score Global: ${score} — Sistema en ${estado.toLowerCase()}`);
+  lines.push('## Dos scores, dos preguntas');
+  lines.push('');
+  lines.push('- **Score estructural**: ¿el paquete está bien armado? (frontmatter,');
+  lines.push('  sintaxis, schemas, manifiestos, versiones consistentes).');
+  lines.push('- **Score conductual**: ¿el sistema hace lo que dice hacer? (cobertura');
+  lines.push('  de tests/evals para componentes críticos: orquestación, evolución,');
+  lines.push('  seguridad, memoria, gateway).');
+  lines.push('');
+  lines.push('Un score estructural alto sin score conductual igual NO implica que el');
+  lines.push('sistema funcione — solo que está bien empaquetado. La separación es');
+  lines.push('honestidad operativa: ver `.planning/adrs/` para histórico de decisiones.');
+  lines.push('');
+  lines.push(`## Score estructural: ${scoreEstructural} — ${estadoEstructural}`);
   lines.push('');
   lines.push('| Componente | Score | Estado | Problemas |');
   lines.push('|------------|-------|--------|-----------|');
@@ -265,19 +352,35 @@ function generarSalud() {
   lines.push(`| Versiones | ${versionConsistente ? '100%' : '0%'} | ${versionConsistente ? 'Consistentes' : 'ERROR'} | package.json = plugin.json = ${pkg.version} |`);
   lines.push('');
 
+  lines.push(`## Score conductual: ${conductual.porcentaje}% — ${estadoConductual}`);
+  lines.push('');
+  lines.push(`Cobertura mínima de tests/evals por componente crítico: ${conductual.cubiertos}/${conductual.total}.`);
+  lines.push('');
+  lines.push('Este score mide **presencia** de tests, no calidad. Un componente con un');
+  lines.push('solo test marca como cubierto. Subir esta cifra requiere agregar evals');
+  lines.push('comportamentales por componente — ver propuesta #4 en `.planning/`.');
+  lines.push('');
+  lines.push('| Componente crítico | Cobertura |');
+  lines.push('|--------------------|-----------|');
+  for (const c of conductual.detalle) {
+    const icono = c.cubierto ? '✅' : '❌';
+    lines.push(`| ${c.id} | ${icono} ${c.cubierto ? 'sí' : 'no — falta eval'} |`);
+  }
+  lines.push('');
+
   if (problemas.length > 0) {
-    lines.push('## Problemas detectados');
+    lines.push('## Problemas estructurales detectados');
     lines.push('');
     for (const p of problemas) lines.push(`- ${p}`);
     lines.push('');
   } else {
-    lines.push('## Problemas críticos');
+    lines.push('## Problemas estructurales');
     lines.push('');
     lines.push('Ninguno.');
     lines.push('');
   }
 
-  lines.push('## Verificaciones positivas');
+  lines.push('## Verificaciones positivas (estructurales)');
   lines.push('');
   lines.push(`- **Frontmatter**: ${agentes.length} agentes + ${skills.length} skills + ${comandos} comandos verificados`);
   lines.push(`- **Skills**: ${skills.length}/${skills.length} con SKILL.md presente`);
@@ -300,7 +403,7 @@ if (AMBOS || SOLO_INV) {
     console.log('=== INVENTARIO.md (dry-run) ===\n');
     console.log(inventario.substring(0, 2000) + '\n...(truncado)');
   } else {
-    fs.writeFileSync(path.join(RAIZ, 'INVENTARIO.md'), inventario, 'utf8');
+    atomicWriteSync(path.join(RAIZ, 'INVENTARIO.md'), inventario, 'utf8');
     console.log('INVENTARIO.md generado correctamente.');
   }
 }
@@ -311,7 +414,7 @@ if (AMBOS || SOLO_SAL) {
     console.log('\n=== SALUD.md (dry-run) ===\n');
     console.log(salud);
   } else {
-    fs.writeFileSync(path.join(RAIZ, 'SALUD.md'), salud, 'utf8');
+    atomicWriteSync(path.join(RAIZ, 'SALUD.md'), salud, 'utf8');
     console.log('SALUD.md generado correctamente.');
   }
 }

package/scripts/generar-matriz-lenguajes.js

@@ -0,0 +1,271 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * generar-matriz-lenguajes.js
+ *
+ * Recorre `agentes/`, `habilidades/` y `reglas/lenguajes/` y produce una
+ * matriz de cobertura por lenguaje en `.planning/cobertura-lenguajes.md`.
+ *
+ * Para cada lenguaje detectado, reporta:
+ *   - Agentes (backend/frontend/mobile/revisor) que lo cubren.
+ *   - Skills (experto, patrones, testing, build-errors).
+ *   - Subdirectorio en reglas/lenguajes/.
+ *   - Status de cobertura: completo (≥4 elementos) | parcial (1-3) | faltante (0).
+ *
+ * Uso: ejecutar como parte de `/swl:salud` o pre-release.
+ *   node scripts/generar-matriz-lenguajes.js
+ *
+ * Zero-deps. Idempotente.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const ROOT = process.cwd();
+const SALIDA = path.join(ROOT, '.planning', 'cobertura-lenguajes.md');
+
+// Cargar atomic-write desde hooks/lib/ (regla obligatoria de CLAUDE.md:
+// escrituras atómicas para archivos de estado y artefactos en .planning/).
+const { atomicWriteSync } = require(path.join(ROOT, 'hooks', 'lib', 'atomic-write.js'));
+
+// ---------------------------------------------------------------------------
+// Lenguajes a evaluar (taxonomía SWL)
+// ---------------------------------------------------------------------------
+
+/**
+ * Cada entrada define:
+ *   - clave: nombre interno usado para matchear archivos.
+ *   - etiqueta: nombre humano para el reporte.
+ *   - agentesEsperados: prefijos/sufijos en agentes/.
+ *   - skillsEsperados: prefijos en habilidades/.
+ *   - reglaSubdir: nombre esperado en reglas/lenguajes/ (null si no aplica).
+ *   - smokeMin: ejemplo mínimo de smoke test en CI.
+ */
+const LENGUAJES = [
+  { clave: 'python',  etiqueta: 'Python',
+    agentesEsperados: ['backend-python-swl'],
+    skillsKeywords:   ['async-python', 'django', 'fastapi', 'python', 'sqlalchemy'],
+    revisor:          null,
+    reglaSubdir:      null,
+    smokeMin:         '`pytest -x` + smoke import de paquete principal.' },
+  { clave: 'node',    etiqueta: 'Node/TypeScript',
+    agentesEsperados: ['backend-node-swl'],
+    skillsKeywords:   ['typescript', 'node-experto', 'fastify', 'express', 'nestjs', 'prisma'],
+    revisor:          'revisor-typescript-swl',
+    reglaSubdir:      null,
+    smokeMin:         '`vitest run` o `jest --ci` + `tsc --noEmit`.' },
+  { clave: 'java',    etiqueta: 'Java',
+    agentesEsperados: ['backend-java-swl'],
+    skillsKeywords:   ['java-experto', 'java-patrones', 'java-testing', 'build-errors-java', 'spring'],
+    revisor:          'revisor-java-swl',
+    reglaSubdir:      'java',
+    smokeMin:         '`mvn test` o `gradle test` con cobertura mínima de JaCoCo.' },
+  { clave: 'go',      etiqueta: 'Go',
+    agentesEsperados: ['backend-go-swl'],
+    skillsKeywords:   ['go-experto', 'go-patrones', 'go-testing', 'build-errors-go'],
+    revisor:          'revisor-go-swl',
+    reglaSubdir:      'go',
+    smokeMin:         '`go test ./... -race -count=1`.' },
+  { clave: 'rust',    etiqueta: 'Rust',
+    agentesEsperados: ['backend-rust-swl'],
+    skillsKeywords:   ['rust-experto', 'rust-patrones', 'rust-testing', 'build-errors-rust', 'axum', 'actix'],
+    revisor:          'revisor-rust-swl',
+    reglaSubdir:      'rust',
+    smokeMin:         '`cargo test` + `cargo clippy -- -D warnings`.' },
+  { clave: 'csharp',  etiqueta: 'C# / .NET',
+    agentesEsperados: ['backend-csharp-swl'],
+    skillsKeywords:   ['csharp-experto', 'csharp-patrones', 'csharp-testing', 'build-errors-csharp', 'efcore'],
+    revisor:          'revisor-csharp-swl',
+    reglaSubdir:      'csharp',
+    smokeMin:         '`dotnet test --no-build` con xUnit/NUnit y coverlet.' },
+  { clave: 'php',     etiqueta: 'PHP / Laravel',
+    agentesEsperados: [],
+    skillsKeywords:   ['php-experto', 'php-patrones', 'php-testing', 'build-errors-php', 'laravel'],
+    revisor:          'revisor-php-swl',
+    reglaSubdir:      'php',
+    smokeMin:         '`vendor/bin/phpunit` o `pest` + `phpstan analyse`.' },
+  { clave: 'kotlin',  etiqueta: 'Kotlin (Android)',
+    agentesEsperados: ['mobile-android-swl'],
+    skillsKeywords:   ['kotlin-compose', 'kotlin-experto', 'kotlin-testing', 'build-errors-kotlin'],
+    revisor:          'revisor-kotlin-swl',
+    reglaSubdir:      'kotlin',
+    smokeMin:         '`./gradlew test connectedAndroidTest` (al menos JVM tests).' },
+  { clave: 'swift',   etiqueta: 'Swift (iOS)',
+    agentesEsperados: ['mobile-ios-swl'],
+    skillsKeywords:   ['swift-experto', 'swift-patrones', 'swift-testing', 'build-errors-swift', 'swiftui'],
+    revisor:          'revisor-swift-swl',
+    reglaSubdir:      'swift',
+    smokeMin:         '`swift test` o `xcodebuild test` en scheme primario.' },
+  { clave: 'react',   etiqueta: 'React',
+    agentesEsperados: ['frontend-react-swl'],
+    skillsKeywords:   ['react', 'frontend-react'],
+    revisor:          'revisor-react-swl',
+    reglaSubdir:      null,
+    smokeMin:         'React Testing Library con cobertura mínima de smoke render.' },
+  { clave: 'angular', etiqueta: 'Angular',
+    agentesEsperados: ['frontend-angular-swl'],
+    skillsKeywords:   ['angular-avanzado', 'angular-moderno'],
+    revisor:          'revisor-angular-swl',
+    reglaSubdir:      null,
+    smokeMin:         '`ng test --watch=false --no-progress` con headless Chrome.' },
+  { clave: 'nextjs',  etiqueta: 'Next.js',
+    agentesEsperados: [],
+    skillsKeywords:   ['nextjs-experto', 'nextjs-patrones', 'nextjs-testing', 'build-errors-nextjs'],
+    revisor:          'revisor-nextjs-swl',
+    reglaSubdir:      'nextjs',
+    smokeMin:         '`next build` + Playwright sobre rutas críticas.' },
+  { clave: 'reactnative', etiqueta: 'React Native / Flutter',
+    agentesEsperados: ['mobile-cross-swl'],
+    skillsKeywords:   ['mobile-react-native', 'mobile-flutter', 'mobile-cross'],
+    revisor:          null,
+    reglaSubdir:      null,
+    smokeMin:         '`detox test` (RN) o `flutter test` + `flutter analyze`.' },
+];
+
+// ---------------------------------------------------------------------------
+// Detección
+// ---------------------------------------------------------------------------
+
+function listarSeguro(dir) {
+  try { return fs.readdirSync(path.join(ROOT, dir)); }
+  catch { return []; }
+}
+
+function detectarCobertura(lang) {
+  const agentesDisco = listarSeguro('agentes');
+  const skillsDisco  = listarSeguro('habilidades');
+  const reglasDisco  = listarSeguro('reglas/lenguajes');
+
+  const agentes = lang.agentesEsperados.filter(a =>
+    agentesDisco.includes(a + '.md'));
+  const revisor = lang.revisor && agentesDisco.includes(lang.revisor + '.md')
+    ? lang.revisor
+    : null;
+  const skills  = skillsDisco.filter(s =>
+    lang.skillsKeywords.some(k => s.toLowerCase().includes(k.toLowerCase())));
+  const regla   = lang.reglaSubdir && reglasDisco.includes(lang.reglaSubdir)
+    ? lang.reglaSubdir
+    : null;
+
+  const elementos = agentes.length + (revisor ? 1 : 0) + skills.length + (regla ? 1 : 0);
+  let status;
+  if (elementos === 0)        status = 'faltante';
+  else if (elementos < 4)     status = 'parcial';
+  else                        status = 'completo';
+
+  return { agentes, revisor, skills, regla, elementos, status };
+}
+
+// ---------------------------------------------------------------------------
+// Render
+// ---------------------------------------------------------------------------
+
+function renderTabla() {
+  const filas = LENGUAJES.map(lang => {
+    const cov = detectarCobertura(lang);
+    const icono = cov.status === 'completo' ? '✅' : cov.status === 'parcial' ? '⚠️' : '❌';
+    const agenteCelda = cov.agentes.length > 0 ? cov.agentes.join(', ') : '—';
+    const revisorCelda = cov.revisor || '—';
+    const skillsCelda = cov.skills.length > 0 ? `${cov.skills.length} skill(s)` : '—';
+    const reglaCelda = cov.regla ? `reglas/lenguajes/${cov.regla}/` : '—';
+    return `| ${icono} ${lang.etiqueta} | ${agenteCelda} | ${revisorCelda} | ${skillsCelda} | ${reglaCelda} | ${cov.status} |`;
+  });
+
+  return [
+    '| Lenguaje | Agente(s) | Revisor | Skills | Regla por-lenguaje | Status |',
+    '|----------|-----------|---------|--------|--------------------|--------|',
+    ...filas,
+  ].join('\n');
+}
+
+function renderSmoke() {
+  return LENGUAJES.map(lang => {
+    const cov = detectarCobertura(lang);
+    const tag = cov.status === 'faltante'
+      ? '_(sin cobertura SWL — el smoke aplica solo si el proyecto del usuario lo usa)_'
+      : '';
+    return `### ${lang.etiqueta}\n\n- Smoke mínimo: ${lang.smokeMin}\n${tag ? '- ' + tag + '\n' : ''}`;
+  }).join('\n');
+}
+
+function renderResumen() {
+  const total = LENGUAJES.length;
+  const completos = LENGUAJES.filter(l => detectarCobertura(l).status === 'completo').length;
+  const parciales = LENGUAJES.filter(l => detectarCobertura(l).status === 'parcial').length;
+  const faltantes = LENGUAJES.filter(l => detectarCobertura(l).status === 'faltante').length;
+  return [
+    `**Total lenguajes evaluados**: ${total}`,
+    `**Cobertura completa** (≥4 elementos: agente + revisor + skills + regla): ${completos}`,
+    `**Cobertura parcial** (1-3 elementos): ${parciales}`,
+    `**Sin cobertura SWL**: ${faltantes}`,
+  ].join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+function main() {
+  const fecha = new Date().toISOString().slice(0, 10);
+  const contenido = `# Matriz de cobertura SWL × lenguaje
+
+> **Generado automáticamente** por \`scripts/generar-matriz-lenguajes.js\`.
+> Última generación: ${fecha}.
+> NO editar a mano — re-ejecutar el script.
+
+Esta matriz documenta qué lenguajes del stack polyglot SWL tienen cobertura
+completa de **agentes + skills + reglas + revisores**, y qué smoke test mínimo
+debería ejecutarse en CI antes de release de un proyecto que use cada lenguaje.
+
+Aplica a:
+
+- **Pre-release del repo madre swl-ses**: validar que ningún lenguaje
+  declarado oficialmente perdió componentes desde el último release.
+- **Proyectos usuario**: usar la columna "Smoke mínimo" como guía de qué
+  ejecutar como mínimo antes de \`/swl:release\` en su proyecto.
+
+## Resumen
+
+${renderResumen()}
+
+## Cobertura por lenguaje
+
+${renderTabla()}
+
+**Leyenda**:
+- ✅ **completo**: ≥4 elementos (agente backend/frontend/mobile + revisor + skills + regla por-lenguaje).
+- ⚠️ **parcial**: 1-3 elementos. Aceptable si el lenguaje es de uso secundario.
+- ❌ **faltante**: ningún elemento detectado. Si el proyecto declara este lenguaje, la cobertura SWL es inadecuada.
+
+## Smoke test mínimo recomendado por lenguaje
+
+${renderSmoke()}
+
+## Cómo se usa esta matriz
+
+1. **Pre-release de swl-ses**: \`/swl:release\` invoca este script. Si algún
+   lenguaje pasó de **completo** a **parcial** o de **parcial** a **faltante**
+   sin ADR documentado, el release se bloquea.
+2. **CI de proyecto usuario**: el comando \`/swl:configurar-ci\` genera el
+   workflow incluyendo el smoke mínimo del lenguaje detectado.
+3. **Auditoría**: ejecutar \`node scripts/generar-matriz-lenguajes.js\` cuando
+   se agrega/elimina un agente, skill o regla por-lenguaje. La salida actualizada
+   debe commitearse junto al cambio.
+
+## Política de cierre por categoría
+
+- **Lenguaje completo (✅)**: cualquier eliminación de componente requiere ADR
+  en \`.planning/adrs/\` justificando la regresión.
+- **Lenguaje parcial (⚠️)**: documentar en este archivo el plan para llegar a
+  cobertura completa, o decisión explícita de mantener parcial (con razón).
+- **Lenguaje faltante (❌)**: el repo no debe afirmar soporte oficial. Mover
+  cualquier mención a "stack polyglot soportado" hasta que pase a parcial.
+`;
+
+  atomicWriteSync(SALIDA, contenido, 'utf8');
+  console.log(`Matriz generada: ${path.relative(ROOT, SALIDA)}`);
+  console.log(renderResumen());
+}
+
+main();

package/scripts/generar-skills-lock.js

@@ -0,0 +1,190 @@
+#!/usr/bin/env node
+/**
+ * generar-skills-lock.js
+ *
+ * Genera `manifiestos/skills-lock.json` con SHA256 de cada `habilidades/*\/SKILL.md`.
+ * Permite detectar drift silencioso: alguien edita un skill localmente sin
+ * commit y nadie lo nota hasta que falla. El lock se regenera en cada
+ * `/swl:release` y se valida en `/swl:salud`.
+ *
+ * Uso:
+ *   node scripts/generar-skills-lock.js               # genera y escribe
+ *   node scripts/generar-skills-lock.js --check       # compara, falla si hay drift
+ *   node scripts/generar-skills-lock.js --json        # imprime resumen JSON
+ *
+ * Origen: análisis de temp/design.md-main/skills-lock.json (mayo 2026).
+ *
+ * Zero-dependencies. Compatible Windows (CRLF-safe), Node 18+.
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+
+const ROOT = path.resolve(__dirname, '..');
+
+// Escritura atómica obligatoria (regla CLAUDE.md). Fallback defensivo.
+let atomicWriteSync;
+try {
+  ({ atomicWriteSync } = require(path.join(ROOT, 'hooks', 'lib', 'atomic-write.js')));
+} catch {
+  atomicWriteSync = (p, c, e) => fs.writeFileSync(p, c, e);
+}
+const HABILIDADES_DIR = path.join(ROOT, 'habilidades');
+const LOCK_FILE = path.join(ROOT, 'manifiestos', 'skills-lock.json');
+const LOCK_VERSION = 1;
+
+const CHECK = process.argv.includes('--check');
+const JSON_OUT = process.argv.includes('--json');
+
+function sha256(buffer) {
+  return crypto.createHash('sha256').update(buffer).digest('hex');
+}
+
+function leerFrontmatter(contenido) {
+  const m = contenido.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n/);
+  if (!m) return {};
+  const fm = {};
+  for (const linea of m[1].split(/\r?\n/)) {
+    const kv = linea.match(/^([a-zA-Z_][a-zA-Z0-9_-]*):\s*(.*)$/);
+    if (kv) fm[kv[1]] = kv[2].trim();
+  }
+  return fm;
+}
+
+function generarLock() {
+  if (!fs.existsSync(HABILIDADES_DIR)) {
+    console.error(`ERROR: directorio no encontrado: ${HABILIDADES_DIR}`);
+    process.exit(2);
+  }
+
+  const skills = [];
+  const dirs = fs
+    .readdirSync(HABILIDADES_DIR, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name)
+    .sort();
+
+  for (const dir of dirs) {
+    const skillFile = path.join(HABILIDADES_DIR, dir, 'SKILL.md');
+    if (!fs.existsSync(skillFile)) {
+      // Skill sin SKILL.md — anomalía pero no fatal
+      skills.push({
+        nombre: dir,
+        path: `habilidades/${dir}/SKILL.md`,
+        hash: null,
+        bytes: 0,
+        warning: 'skill-md-faltante',
+      });
+      continue;
+    }
+
+    const buffer = fs.readFileSync(skillFile);
+    const contenido = buffer.toString('utf-8');
+    const fm = leerFrontmatter(contenido);
+
+    skills.push({
+      nombre: fm.name || dir,
+      path: `habilidades/${dir}/SKILL.md`,
+      hash: `sha256:${sha256(buffer)}`,
+      bytes: buffer.length,
+      version: fm.version || null,
+    });
+  }
+
+  // Hash agregado del lock completo (excluyendo timestamps)
+  const datosCanonicos = JSON.stringify(
+    skills.map((s) => ({ nombre: s.nombre, hash: s.hash })),
+    null,
+    0
+  );
+  const lockHash = `sha256:${sha256(Buffer.from(datosCanonicos, 'utf-8'))}`;
+
+  return {
+    lockfileVersion: LOCK_VERSION,
+    generatedAt: new Date().toISOString(),
+    skillsCount: skills.length,
+    lockHash,
+    skills,
+  };
+}
+
+function comparar(actual, anterior) {
+  if (!anterior) return { drifted: [], faltantes: actual.skills, nuevos: [] };
+
+  const anteriorMap = new Map(anterior.skills.map((s) => [s.nombre, s]));
+  const actualMap = new Map(actual.skills.map((s) => [s.nombre, s]));
+
+  const drifted = [];
+  const nuevos = [];
+  const faltantes = [];
+
+  for (const s of actual.skills) {
+    const prev = anteriorMap.get(s.nombre);
+    if (!prev) {
+      nuevos.push(s.nombre);
+    } else if (prev.hash !== s.hash) {
+      drifted.push({ nombre: s.nombre, antes: prev.hash, ahora: s.hash });
+    }
+  }
+  for (const s of anterior.skills) {
+    if (!actualMap.has(s.nombre)) {
+      faltantes.push(s.nombre);
+    }
+  }
+
+  return { drifted, faltantes, nuevos };
+}
+
+function main() {
+  const actual = generarLock();
+
+  if (CHECK) {
+    if (!fs.existsSync(LOCK_FILE)) {
+      console.error(`ERROR: ${LOCK_FILE} no existe. Ejecutar sin --check para generarlo.`);
+      process.exit(1);
+    }
+    const anterior = JSON.parse(fs.readFileSync(LOCK_FILE, 'utf-8'));
+    const diff = comparar(actual, anterior);
+    const total = diff.drifted.length + diff.faltantes.length + diff.nuevos.length;
+
+    if (JSON_OUT) {
+      console.log(JSON.stringify({ ok: total === 0, ...diff }, null, 2));
+    } else if (total === 0) {
+      console.log(`✓ skills-lock OK: ${actual.skillsCount} skills sin drift`);
+    } else {
+      console.log(`✗ skills-lock DRIFT detectado:`);
+      if (diff.drifted.length) {
+        console.log(`  Modificados (${diff.drifted.length}):`);
+        diff.drifted.forEach((d) => console.log(`    - ${d.nombre}`));
+      }
+      if (diff.nuevos.length) {
+        console.log(`  Nuevos (${diff.nuevos.length}):`);
+        diff.nuevos.forEach((n) => console.log(`    - ${n}`));
+      }
+      if (diff.faltantes.length) {
+        console.log(`  Faltantes (${diff.faltantes.length}):`);
+        diff.faltantes.forEach((n) => console.log(`    - ${n}`));
+      }
+      console.log(`\n  Para regenerar: node scripts/generar-skills-lock.js`);
+    }
+    process.exit(total === 0 ? 0 : 1);
+  }
+
+  // Generar
+  atomicWriteSync(LOCK_FILE, JSON.stringify(actual, null, 2) + '\n', 'utf-8');
+  if (JSON_OUT) {
+    console.log(JSON.stringify({ ok: true, file: LOCK_FILE, count: actual.skillsCount }));
+  } else {
+    console.log(`✓ Generado ${LOCK_FILE}`);
+    console.log(`  ${actual.skillsCount} skills, lockHash=${actual.lockHash.slice(0, 23)}...`);
+  }
+}
+
+if (require.main === module) {
+  main();
+}
+
+module.exports = { generarLock, comparar };

package/scripts/lib/estado.js

@@ -8,6 +8,16 @@
 const fs = require('fs');
 const path = require('path');
 
+// Escritura atómica obligatoria — el archivo de estado de instalación
+// (.swl-install-state.json) es lo que doctor/repair/uninstall consultan.
+// Corromperlo durante una migración v2→v3 deja la instalación en limbo.
+let atomicWriteJSON;
+try {
+  ({ atomicWriteJSON } = require(path.join(__dirname, '..', '..', 'hooks', 'lib', 'atomic-write.js')));
+} catch {
+  atomicWriteJSON = (p, o) => fs.writeFileSync(p, JSON.stringify(o, null, 2), 'utf-8');
+}
+
 const NOMBRE_ESTADO = '.swl-install-state.json';
 
 /**
@@ -61,7 +71,7 @@ function registrarComponente(estado, componente) {
  */
 function guardarEstado(estado, directorio) {
   const rutaEstado = path.join(directorio, NOMBRE_ESTADO);
-  fs.writeFileSync(rutaEstado, JSON.stringify(estado, null, 2), 'utf-8');
+  atomicWriteJSON(rutaEstado, estado);
   return rutaEstado;
 }
 
@@ -83,7 +93,7 @@ function cargarEstado(directorio) {
         estado.componentesExternos = [];
       }
       // Persistir la migración
-      fs.writeFileSync(rutaEstado, JSON.stringify(estado, null, 2), 'utf-8');
+      atomicWriteJSON(rutaEstado, estado);
     }
     return estado;
   } catch {