@saulwade/swl-ses 1.0.1 → 1.1.2

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 {

package/scripts/lib/gitignore-manifest.js

@@ -18,6 +18,15 @@
 const fs = require("fs");
 const path = require("path");
 
+// Atomic write para .gitignore y manifest. Estos archivos viven en el
+// repo del usuario; corromperlos durante install puede romper su workflow.
+let atomicWriteSync;
+try {
+  ({ atomicWriteSync } = require(path.join(__dirname, "..", "..", "hooks", "lib", "atomic-write.js")));
+} catch {
+  atomicWriteSync = (p, c, e) => fs.writeFileSync(p, c, e);
+}
+
 const MARKER_INICIO = "# [swl-ses:inicio]";
 const MARKER_FIN = "# [swl-ses:fin]";
 const MANIFEST_FILE = ".swl-ses";
@@ -126,6 +135,27 @@ const ENTRADAS_POR_RUNTIME = {
  * @returns {string}            Ruta al .gitignore
  */
 function actualizarGitignore(cwd, extras = []) {
+  // Guarda defensiva: el bloque inyectado dice "swl-ses es tooling de
+  // desarrollo — no forma parte del proyecto". En el repo madre, swl-ses
+  // ES el proyecto, así que el bloque no aplica y rompería trackings
+  // legítimos (.planning/APRENDIZAJES.md, instintos/, hooks/). Si se
+  // detecta el package.json del madre, abortar sin tocar el .gitignore.
+  const pkgPath = path.join(cwd, "package.json");
+  if (fs.existsSync(pkgPath)) {
+    try {
+      const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf-8"));
+      const esRepoMadre =
+        pkg.name === "@saulwade/swl-ses" ||
+        pkg.name === "@saul-wade/swl-ses" ||
+        pkg.name === "swl-ses";
+      if (esRepoMadre) {
+        return path.join(cwd, ".gitignore"); // no-op
+      }
+    } catch (_) {
+      // package.json corrupto — proceder con la lógica normal
+    }
+  }
+
   const gitignorePath = path.join(cwd, ".gitignore");
   let existente = fs.existsSync(gitignorePath)
     ? fs.readFileSync(gitignorePath, "utf-8")
@@ -168,7 +198,7 @@ function actualizarGitignore(cwd, extras = []) {
     "",
   ].join("\n");
 
-  fs.writeFileSync(gitignorePath, existente.trimEnd() + seccion, "utf-8");
+  atomicWriteSync(gitignorePath, existente.trimEnd() + seccion, "utf-8");
   return gitignorePath;
 }
 
@@ -214,7 +244,7 @@ function escribirManifest(cwd, data) {
   const manifestPath = path.join(cwd, MANIFEST_FILE);
   const existente = leerManifest(cwd) || {};
   const manifest = { ...existente, ...data };
-  fs.writeFileSync(
+  atomicWriteSync(
     manifestPath,
     JSON.stringify(manifest, null, 2) + "\n",
     "utf-8",