@saulwade/swl-ses 2.6.1 → 2.8.0

package/scripts/generar-harness-ir.js

@@ -0,0 +1,257 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Genera o verifica la vista diagnóstica del Harness IR.
+ * La publicación usa temp + fsync + CAS + replace entre escritores cooperativos.
+ * La CLI es el único escritor autorizado; procesos con privilegios equivalentes que
+ * ignoren el lock quedan fuera del modelo de amenaza portable de F29.
+ */
+
+const childProcess = require('node:child_process');
+const crypto = require('node:crypto');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { compilarHarnessIR, serializarVista } = require('./lib/harness-ir');
+
+const MODOS = new Set(['--check', '--write']);
+const NOMBRE_VISTA = 'harness-ir.json';
+
+function sha256(contenido) {
+  return crypto.createHash('sha256').update(contenido).digest('hex');
+}
+
+function resolverModo(args) {
+  if (!Array.isArray(args) || args.length !== 1) return null;
+  return MODOS.has(args[0]) ? args[0] : null;
+}
+
+function resolverRutaVista() {
+  const declarada = childProcess.execFileSync('git', ['rev-parse', '--show-toplevel'], {
+    cwd: process.cwd(),
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim();
+  if (/^[\\/]{2}/u.test(declarada)) throw new Error('Raíz UNC prohibida');
+  const root = path.resolve(declarada);
+  const rootStat = fs.lstatSync(root);
+  if (rootStat.isSymbolicLink()) throw new Error('Raíz enlazada prohibida');
+  const rootReal = fs.realpathSync(root);
+  const directorio = path.join(root, 'manifiestos');
+  const directorioStat = fs.lstatSync(directorio);
+  if (directorioStat.isSymbolicLink() || !directorioStat.isDirectory()) {
+    throw new Error('Directorio de salida inválido');
+  }
+  const directorioReal = fs.realpathSync(directorio);
+  if (path.dirname(directorioReal) !== rootReal) throw new Error('Salida fuera de raíz');
+  return path.join(directorio, NOMBRE_VISTA);
+}
+
+function obtenerStatDestino(ruta) {
+  let stat;
+  try {
+    stat = fs.lstatSync(ruta);
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+  if (stat.isSymbolicLink() || !stat.isFile()) throw new Error('Destino inválido');
+  const directorioReal = fs.realpathSync(path.dirname(ruta));
+  const real = fs.realpathSync(ruta);
+  if (path.dirname(real) !== directorioReal) {
+    throw new Error('Destino fuera del directorio confinado');
+  }
+  return { stat, real };
+}
+
+function validarDestino(ruta) {
+  return obtenerStatDestino(ruta);
+}
+
+function mismaIdentidad(antes, despues) {
+  return antes.dev === despues.dev
+    && antes.ino === despues.ino
+    && antes.size === despues.size
+    && antes.mtimeMs === despues.mtimeMs
+    && antes.ctimeMs === despues.ctimeMs
+    && antes.mode === despues.mode;
+}
+
+function leerDestinoEstable(ruta, snapshot) {
+  const flags = fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0);
+  const descriptor = fs.openSync(ruta, flags);
+  let bytes;
+  try {
+    const abierta = fs.fstatSync(descriptor);
+    if (!mismaIdentidad(snapshot.stat, abierta)) throw new Error('Destino cambió antes de leer');
+    bytes = fs.readFileSync(descriptor);
+    if (!mismaIdentidad(abierta, fs.fstatSync(descriptor))) {
+      throw new Error('Destino cambió durante la lectura');
+    }
+  } finally {
+    fs.closeSync(descriptor);
+  }
+  const despues = obtenerStatDestino(ruta);
+  if (!despues || snapshot.real !== despues.real || !mismaIdentidad(snapshot.stat, despues.stat)) {
+    throw new Error('Destino cambió durante la lectura');
+  }
+  return bytes;
+}
+
+function leerOpcional(ruta) {
+  const snapshot = obtenerStatDestino(ruta);
+  return snapshot ? leerDestinoEstable(ruta, snapshot) : null;
+}
+
+function sonMismosBytes(a, b) {
+  if (a === null || b === null) return a === b;
+  return Buffer.from(a).equals(Buffer.from(b));
+}
+
+function finalizar(code, evidencia = {}) {
+  process.exitCode = code;
+  return { code, ...evidencia };
+}
+
+function evidenciaPreservada(bytes) {
+  return bytes === null ? {} : { preservedSha256: sha256(bytes) };
+}
+
+function prepararVista() {
+  const vista = compilarHarnessIR();
+  const bytes = serializarVista(vista);
+  return {
+    vista,
+    bytes,
+    previewSha256: sha256(bytes),
+  };
+}
+
+function verificarVista(ruta, previa, preparada) {
+  if (preparada.vista.counts.errors > 0) {
+    return finalizar(2, {
+      previewSha256: preparada.previewSha256,
+      ...evidenciaPreservada(previa),
+    });
+  }
+  const actual = leerOpcional(ruta);
+  const code = sonMismosBytes(actual, Buffer.from(preparada.bytes)) ? 0 : 1;
+  return finalizar(code, { previewSha256: preparada.previewSha256 });
+}
+
+function rutaTemporal(ruta) {
+  return `${ruta}.tmp-${process.pid}`;
+}
+
+function persistirTemporal(temporal, bytes) {
+  fs.writeFileSync(temporal, bytes, { encoding: 'utf8', flag: 'wx', mode: 0o600 });
+  const descriptor = fs.openSync(temporal, 'r+');
+  try {
+    fs.fsyncSync(descriptor);
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+function limpiarTemporal(temporal) {
+  try {
+    fs.unlinkSync(temporal);
+    return true;
+  } catch (error) {
+    return error.code === 'ENOENT';
+  }
+}
+
+function adquirirLock(ruta) {
+  const lockPath = `${ruta}.lock`;
+  const descriptor = fs.openSync(lockPath, 'wx', 0o600);
+  return { descriptor, path: lockPath };
+}
+
+function liberarLock(lock) {
+  let ok = true;
+  try {
+    fs.closeSync(lock.descriptor);
+  } catch (_error) {
+    ok = false;
+  }
+  try {
+    fs.unlinkSync(lock.path);
+  } catch (_error) {
+    ok = false;
+  }
+  return ok;
+}
+
+function sincronizarDirectorio(directorio) {
+  const descriptor = fs.openSync(directorio, 'r');
+  try {
+    fs.fsyncSync(descriptor);
+  } catch (error) {
+    const noSoportado = process.platform === 'win32'
+      && (error.code === 'EPERM' || error.code === 'EINVAL');
+    if (!noSoportado) throw error;
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+function publicarVista(ruta, previa, preparada) {
+  const evidencia = {
+    previewSha256: preparada.previewSha256,
+    ...evidenciaPreservada(previa),
+  };
+  if (preparada.vista.counts.errors > 0) return finalizar(2, evidencia);
+  const temporal = rutaTemporal(ruta);
+  let code = 2;
+  let lock;
+  let limpiar = false;
+  let committed = false;
+  try {
+    lock = adquirirLock(ruta);
+    validarDestino(ruta);
+    if (sonMismosBytes(previa, leerOpcional(ruta))) {
+      limpiar = true;
+      persistirTemporal(temporal, preparada.bytes);
+      fs.renameSync(temporal, ruta);
+      limpiar = false;
+      committed = true;
+      sincronizarDirectorio(path.dirname(ruta));
+      code = 0;
+    }
+  } catch (_error) {
+    code = 2;
+  } finally {
+    if (limpiar && !limpiarTemporal(temporal)) code = 2;
+    if (lock && !liberarLock(lock)) code = 2;
+  }
+  return finalizar(code, {
+    ...evidencia,
+    ...(committed ? { committed: true } : {}),
+  });
+}
+
+function main(args) {
+  const modo = resolverModo(args);
+  if (!modo) return finalizar(64);
+  let ruta;
+  let previa;
+  try {
+    ruta = resolverRutaVista();
+    previa = leerOpcional(ruta);
+  } catch (_error) {
+    return finalizar(2);
+  }
+  try {
+    const preparada = prepararVista();
+    if (modo === '--check') return verificarVista(ruta, previa, preparada);
+    return publicarVista(ruta, previa, preparada);
+  } catch (_error) {
+    return finalizar(2, evidenciaPreservada(previa));
+  }
+}
+
+if (require.main === module) main(process.argv.slice(2));
+
+module.exports = { main };

package/scripts/generar-inventario.js

@@ -18,6 +18,8 @@
 
 const fs   = require('fs');
 const path = require('path');
+const { renderBloque } = require('./generar-claims-runtime');
+const { CENTINELA_TODOS, SKILLS_EXTERNAS_SET } = require('./lib/skills-externas');
 
 const RAIZ = path.resolve(__dirname, '..');
 
@@ -29,13 +31,6 @@ try {
 } 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');
-const SOLO_SAL = args.has('--salud');
-const SOLO_LLMS = args.has('--llms');
-const AMBOS = !SOLO_INV && !SOLO_SAL && !SOLO_LLMS;
-
 // ── Helpers ────────────────────────────────────────────────────────────
 
 function leerFrontmatter(ruta) {
@@ -244,6 +239,8 @@ function generarInventario() {
   lines.push(`| Contextos | ${contextos} |`);
   lines.push(`| Plantillas | ${plantillasTotal} |`);
   lines.push('');
+  lines.push(renderBloque());
+  lines.push('');
 
   // Equipos
   lines.push('## Equipos de agentes (paralelización real)');
@@ -630,28 +627,22 @@ function generarMapeo() {
   L.push('');
   L.push('| Agente | # | skillsInvocables |');
   L.push('|--------|---|------------------|');
-  // Skills de la colección oficial Anthropic (opt-in, instaladas en
-  // .claude/skills/ vía `swl-ses skills add anthropics/skills`) — referencias
-  // legítimas aunque no vivan en habilidades/. Ver MANUAL_USO § Anthropic Skills.
-  const SKILLS_ANTHROPIC = new Set([
-    'pdf', 'docx', 'xlsx', 'pptx', 'frontend-design', 'web-artifacts-builder',
-    'canvas-design', 'algorithmic-art', 'theme-factory', 'slack-gif-creator',
-    'claude-api', 'mcp-builder', 'webapp-testing', 'doc-coauthoring',
-    'internal-comms', 'brand-guidelines', 'skill-creator',
-  ]);
   const externas = new Set();
   const inexistentes = [];
   for (const a of [...agentes].sort((x, y) => x.name.localeCompare(y.name))) {
     for (const s of a.skillsInvocables) {
-      if (s === 'todos') continue; // centinela: el agente puede invocar cualquier skill
+      if (s === CENTINELA_TODOS) continue;
       if (nombresSkill.has(s)) continue;
-      if (SKILLS_ANTHROPIC.has(s)) externas.add(s);
+      if (SKILLS_EXTERNAS_SET.has(s)) externas.add(s);
       else inexistentes.push(`${a.name} → ${s}`);
     }
-    const etiqueta = a.skillsInvocables.includes('todos')
+    const etiqueta = a.skillsInvocables.includes(CENTINELA_TODOS)
       ? 'todos (acceso a cualquier skill)'
       : (a.skillsInvocables.join(', ') || '—');
-    L.push(`| ${a.name} | ${a.skillsInvocables.includes('todos') ? skills.length : a.skillsInvocables.length} | ${etiqueta} |`);
+    const cantidad = a.skillsInvocables.includes(CENTINELA_TODOS)
+      ? skills.length
+      : a.skillsInvocables.length;
+    L.push(`| ${a.name} | ${cantidad} | ${etiqueta} |`);
   }
   L.push('');
   if (externas.size > 0) {
@@ -683,46 +674,53 @@ function generarMapeo() {
 
 // ── Ejecutar ──────────────────────────────────────────────────────────
 
-if (AMBOS || SOLO_INV) {
-  const inventario = generarInventario();
-  if (DRY) {
-    console.log('=== INVENTARIO.md (dry-run) ===\n');
-    console.log(inventario.substring(0, 2000) + '\n...(truncado)');
-  } else {
-    atomicWriteSync(path.join(RAIZ, 'INVENTARIO.md'), inventario, 'utf8');
-    console.log('INVENTARIO.md generado correctamente.');
+function emitirArtefacto(artefacto, dryRun) {
+  const contenido = artefacto.generar();
+  if (dryRun) {
+    console.log(artefacto.encabezado);
+    const vista = artefacto.limite
+      ? contenido.substring(0, artefacto.limite) + '\n...(truncado)'
+      : contenido;
+    console.log(vista);
+    return;
   }
+  atomicWriteSync(path.join(RAIZ, artefacto.ruta), contenido, 'utf8');
+  console.log(`${path.basename(artefacto.ruta)} generado correctamente.`);
 }
 
-if (AMBOS || SOLO_SAL) {
-  const salud = generarSalud();
-  if (DRY) {
-    console.log('\n=== SALUD.md (dry-run) ===\n');
-    console.log(salud);
-  } else {
-    atomicWriteSync(path.join(RAIZ, 'SALUD.md'), salud, 'utf8');
-    console.log('SALUD.md generado correctamente.');
-  }
+function definirArtefactos(args) {
+  const soloInventario = args.has('--inventario');
+  const soloSalud = args.has('--salud');
+  const soloLlms = args.has('--llms');
+  const ambos = !soloInventario && !soloSalud && !soloLlms;
+  return [
+    { activo: ambos || soloInventario, ruta: 'INVENTARIO.md', generar: generarInventario,
+      encabezado: '=== INVENTARIO.md (dry-run) ===\n', limite: 2000 },
+    { activo: ambos || soloSalud, ruta: 'SALUD.md', generar: generarSalud,
+      encabezado: '\n=== SALUD.md (dry-run) ===\n' },
+    { activo: ambos || soloLlms, ruta: 'llms.txt', generar: generarLlmsTxt,
+      encabezado: '\n=== llms.txt (dry-run) ===\n' },
+    { activo: ambos || args.has('--mapeo'), ruta: path.join('.planning', 'MAPEO_SKILLS_AGENTES.md'),
+      generar: generarMapeo, encabezado: '\n=== MAPEO_SKILLS_AGENTES.md (dry-run) ===\n', limite: 1500 },
+  ];
 }
 
-if (AMBOS || SOLO_LLMS) {
-  const llms = generarLlmsTxt();
-  if (DRY) {
-    console.log('\n=== llms.txt (dry-run) ===\n');
-    console.log(llms);
-  } else {
-    atomicWriteSync(path.join(RAIZ, 'llms.txt'), llms, 'utf8');
-    console.log('llms.txt generado correctamente.');
+function main(argv = process.argv.slice(2)) {
+  const args = new Set(argv);
+  const dryRun = args.has('--dry-run');
+  for (const artefacto of definirArtefactos(args)) {
+    if (artefacto.activo) emitirArtefacto(artefacto, dryRun);
   }
 }
 
-if (AMBOS || args.has('--mapeo')) {
-  const mapeo = generarMapeo();
-  if (DRY) {
-    console.log('\n=== MAPEO_SKILLS_AGENTES.md (dry-run) ===\n');
-    console.log(mapeo.substring(0, 1500) + '\n...(truncado)');
-  } else {
-    atomicWriteSync(path.join(RAIZ, '.planning', 'MAPEO_SKILLS_AGENTES.md'), mapeo, 'utf8');
-    console.log('MAPEO_SKILLS_AGENTES.md generado correctamente.');
-  }
+if (require.main === module) {
+  main();
 }
+
+module.exports = {
+  generarInventario,
+  generarLlmsTxt,
+  generarMapeo,
+  generarSalud,
+  main,
+};

package/scripts/generar-policy-bundle.js

@@ -0,0 +1,202 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Genera o verifica el manifiesto diagnóstico de PolicyBundle.
+ * La publicación portable coordina escritores cooperativos de esta CLI. Procesos
+ * con privilegios equivalentes que ignoran el lock quedan fuera del modelo W2;
+ * no se aceptan raíces ni destinos controlados por el usuario.
+ */
+
+const childProcess = require('node:child_process');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const { compilarPolicyBundle, serializarPolicyBundle } = require('./lib/policy-bundle');
+
+const MODOS = new Set(['--check', '--write']);
+const NOMBRE_MANIFIESTO = 'policy-bundle.json';
+
+function finalizar(code, evidencia = {}) {
+  process.exitCode = code;
+  return { code, ...evidencia };
+}
+
+function resolverModo(args) {
+  return Array.isArray(args) && args.length === 1 && MODOS.has(args[0]) ? args[0] : null;
+}
+
+function capturarDirectorio(directorio, rootReal) {
+  const stat = fs.lstatSync(directorio);
+  if (stat.isSymbolicLink() || !stat.isDirectory()) throw new Error('Salida inválida');
+  const real = fs.realpathSync(directorio);
+  if (path.dirname(real) !== rootReal) throw new Error('Salida fuera de raíz');
+  return { real, fingerprint: identidadDirectorio(stat) };
+}
+
+function identidadDirectorio(stat) {
+  return [stat.dev, stat.ino, stat.birthtimeMs, stat.mode].join(':');
+}
+
+function resolverRuta() {
+  const declarada = childProcess.execFileSync('git', ['rev-parse', '--show-toplevel'], {
+    cwd: process.cwd(),
+    encoding: 'utf8',
+    stdio: ['ignore', 'pipe', 'pipe'],
+  }).trim();
+  if (/^[\\/]{2}/u.test(declarada)) throw new Error('Raíz UNC prohibida');
+  const root = path.resolve(declarada);
+  const rootReal = fs.realpathSync(root);
+  if (fs.lstatSync(root).isSymbolicLink() || path.relative(root, rootReal) !== '') {
+    throw new Error('Raíz enlazada prohibida');
+  }
+  const directorio = path.join(root, 'manifiestos');
+  const identidadSalida = capturarDirectorio(directorio, rootReal);
+  return {
+    directorio,
+    identidadSalida,
+    rootReal,
+    ruta: path.join(directorio, NOMBRE_MANIFIESTO),
+  };
+}
+
+function revalidarDirectorio(contexto) {
+  const actual = capturarDirectorio(contexto.directorio, contexto.rootReal);
+  const esperado = contexto.identidadSalida;
+  if (actual.real !== esperado.real || actual.fingerprint !== esperado.fingerprint) {
+    throw new Error('Directorio de salida cambió');
+  }
+}
+
+function statDestino(ruta) {
+  try {
+    const stat = fs.lstatSync(ruta);
+    if (stat.isSymbolicLink() || !stat.isFile()) throw new Error('Destino inválido');
+    const real = fs.realpathSync(ruta);
+    if (path.dirname(real) !== fs.realpathSync(path.dirname(ruta))) {
+      throw new Error('Destino fuera del directorio');
+    }
+    return { stat, real };
+  } catch (error) {
+    if (error.code === 'ENOENT') return null;
+    throw error;
+  }
+}
+
+function identidad(stat) {
+  return [stat.dev, stat.ino, stat.size, stat.mtimeMs, stat.ctimeMs, stat.mode].join(':');
+}
+
+function leerEstable(ruta) {
+  const inicial = statDestino(ruta);
+  if (!inicial) return null;
+  const descriptor = fs.openSync(ruta, fs.constants.O_RDONLY | (fs.constants.O_NOFOLLOW || 0));
+  let bytes;
+  try {
+    if (identidad(fs.fstatSync(descriptor)) !== identidad(inicial.stat)) {
+      throw new Error('Destino cambió antes de leer');
+    }
+    bytes = fs.readFileSync(descriptor);
+    if (identidad(fs.fstatSync(descriptor)) !== identidad(inicial.stat)) {
+      throw new Error('Destino cambió durante lectura');
+    }
+  } finally {
+    fs.closeSync(descriptor);
+  }
+  const final = statDestino(ruta);
+  if (!final || final.real !== inicial.real || identidad(final.stat) !== identidad(inicial.stat)) {
+    throw new Error('Destino cambió después de leer');
+  }
+  return bytes;
+}
+
+function iguales(a, b) {
+  if (a === null || b === null) return a === b;
+  return Buffer.from(a).equals(Buffer.from(b));
+}
+
+function compilarBytes() {
+  return Buffer.from(serializarPolicyBundle(compilarPolicyBundle()), 'utf8');
+}
+
+function sincronizarDirectorio(directorio) {
+  const descriptor = fs.openSync(directorio, 'r');
+  try {
+    fs.fsyncSync(descriptor);
+  } catch (error) {
+    const noSoportado = process.platform === 'win32'
+      && (error.code === 'EPERM' || error.code === 'EINVAL');
+    if (!noSoportado) throw error;
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+function escribirTemporal(temporal, bytes) {
+  fs.writeFileSync(temporal, bytes, { flag: 'wx', mode: 0o600 });
+  const descriptor = fs.openSync(temporal, 'r+');
+  try {
+    fs.fsyncSync(descriptor);
+  } finally {
+    fs.closeSync(descriptor);
+  }
+}
+
+function limpiar(ruta) {
+  try {
+    fs.unlinkSync(ruta);
+  } catch (error) {
+    if (error.code !== 'ENOENT') throw error;
+  }
+}
+
+function publicar(contexto, previa, bytes) {
+  const { ruta, rootReal } = contexto;
+  const lockPath = path.join(rootReal, '.policy-bundle.lock');
+  const temporal = `${ruta}.tmp-${process.pid}`;
+  let lock;
+  try {
+    lock = fs.openSync(lockPath, 'wx', 0o600);
+    revalidarDirectorio(contexto);
+    if (!iguales(previa, leerEstable(ruta))) throw new Error('CAS rechazado');
+    revalidarDirectorio(contexto);
+    escribirTemporal(temporal, bytes);
+    revalidarDirectorio(contexto);
+    fs.renameSync(temporal, ruta);
+    revalidarDirectorio(contexto);
+    sincronizarDirectorio(contexto.directorio);
+    return finalizar(0, { committed: true });
+  } catch (_error) {
+    try {
+      revalidarDirectorio(contexto);
+      limpiar(temporal);
+    } catch { /* identidad incierta: no seguir paths mutables */ }
+    return finalizar(2);
+  } finally {
+    if (lock !== undefined) fs.closeSync(lock);
+    if (lock !== undefined) limpiar(lockPath);
+  }
+}
+
+function main(args) {
+  const modo = resolverModo(args);
+  if (!modo) return finalizar(64);
+  try {
+    const contexto = resolverRuta();
+    const previa = leerEstable(contexto.ruta);
+    const bytes = compilarBytes();
+    revalidarDirectorio(contexto);
+    if (modo === '--check') {
+      const igualesAlDisco = iguales(leerEstable(contexto.ruta), bytes);
+      revalidarDirectorio(contexto);
+      return finalizar(igualesAlDisco ? 0 : 1);
+    }
+    return publicar(contexto, previa, bytes);
+  } catch (_error) {
+    return finalizar(2);
+  }
+}
+
+if (require.main === module) main(process.argv.slice(2));
+
+module.exports = { main };

package/scripts/instalador.js

@@ -16,7 +16,13 @@
 const fs = require('fs');
 const path = require('path');
 
-const { obtenerRuntime, calcularRutas, resumenDeteccion, detectarInstalacionesDuales } = require('./lib/detectar-runtime');
+const {
+  calcularRutas,
+  detectarInstalacionesDuales,
+  obtenerEtiquetaConformidad,
+  obtenerRuntime,
+  resumenDeteccion,
+} = require('./lib/detectar-runtime');
 const { preguntarSiNo, ES_TTY } = require('./lib/ui');
 const { resolverPerfil, generarPlan } = require('./lib/manifiestos');
 const { crearEstado, registrarArchivo, registrarComponente, guardarEstado, cargarEstado } = require('./lib/estado');
@@ -200,9 +206,11 @@ async function install(opciones) {
     process.exit(1);
   }
 
-  if (runtime.soporte === 'parcial') {
-    console.log(`Nota: Runtime "${target}" (${runtime.nombre}) tiene soporte parcial — solo agentes y reglas.\n`);
-  }
+  const etiquetaConformidad = obtenerEtiquetaConformidad(target);
+  console.log(
+    `Conformidad: ${runtime.nombre} (${target}) = ${etiquetaConformidad}. ` +
+    'La disponibilidad del instalador no equivale a certificación del harness.\n'
+  );
 
   // 1b. Detectar conflicto dual-scope: instalar en un scope cuando el opuesto
   // ya tiene SWL instalado causa duplicación visible de comandos en la UI.
@@ -1145,6 +1153,17 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
     return { instalado: false, razon: `Target "${runtime.id}" no soporta "${archivo.tipo}"` };
   }
 
+  // Base de los backups de actualización. En install GLOBAL no se ancla a
+  // process.cwd(): si el usuario corre `install --global` desde su HOME, cwd es
+  // el HOME y los backups aterrizaban en ~/.planning/backups (bug 2026-07-15,
+  // sembraba un ~/.planning espurio). Se co-ubican con el scope global
+  // (~/.claude/.planning/backups) — el restore usa la rutaBackup absoluta
+  // guardada en el estado, así que reubicar la base es seguro. En install de
+  // proyecto, los backups viven en el proyecto (comportamiento correcto).
+  const rutaBackupBase = opciones.esGlobal
+    ? path.join(require('os').homedir(), '.claude')
+    : process.cwd();
+
   let dirDestino;
 
   switch (archivo.tipo) {
@@ -1330,7 +1349,7 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
 
       if (strategy.strategy === 'conflict') {
         // Población A — evolución del usuario. NUNCA overwrite: backup + merge (diff).
-        const backup = crearBackup(process.cwd(), cmpDestino, versionBackup);
+        const backup = crearBackup(rutaBackupBase, cmpDestino, versionBackup);
         if (!backup.respaldado) {
           console.log(`  ⚠ Backup falló (${backup.error || 'desconocido'}) para ${nombreArchivo} — merge abortado, original preservado`);
           auditEvolved({ archivo: path.relative(process.cwd(), cmpDestino), clasificacion: 'A', accion: 'preserve', hashAntes, evidencia: `backup falló: ${backup.error || 'desconocido'}` });
@@ -1390,7 +1409,7 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
         }
 
         // Componente-archivo (agentes/comandos/reglas): backup del archivo + fall-through.
-        const backup = crearBackup(process.cwd(), cmpDestino, versionBackup);
+        const backup = crearBackup(rutaBackupBase, cmpDestino, versionBackup);
         // H1 (nemesis O5): si el backup falla, NO sobrescribir — preservar original.
         if (!backup.respaldado) {
           console.log(`  ⚠ Backup falló (${backup.error || 'desconocido'}) para ${nombreArchivo} — overwrite abortado, original preservado`);
@@ -1428,7 +1447,7 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
   // Nivel 2: Backup antes de sobreescribir con --force (el caso B shipped-evolved
   // ya hizo su propio backup arriba; no duplicar).
   if (fs.existsSync(destino) && opciones.force && opciones.versionAnterior && !forzarEscrituraEvolved) {
-    const backup = crearBackup(process.cwd(), destino, opciones.versionAnterior);
+    const backup = crearBackup(rutaBackupBase, destino, opciones.versionAnterior);
     if (backup.respaldado) {
       if (typeof opciones.onProgress === 'function') {
         opciones.onProgress({