@saulwade/swl-ses 2.2.1 → 2.2.4

package/scripts/instalador.js

@@ -606,6 +606,7 @@ async function install(opciones) {
     try {
       const resultado = instalarArchivo(archivo, rutas, runtime, {
         force,
+        esGlobal,
         versionAnterior,
         versionActual: VERSION,
         estado,
@@ -683,7 +684,7 @@ async function install(opciones) {
   // Instalar userland (prioridad sobre core)
   for (const archivo of archivosUserland) {
     try {
-      const resultado = instalarArchivo(archivo, rutas, runtime, { force: true });
+      const resultado = instalarArchivo(archivo, rutas, runtime, { force: true, esGlobal });
       if (resultado.instalado) {
         registrarArchivo(estado, {
           origen: archivo.rutaRelativa,
@@ -1173,6 +1174,18 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
     const cmpOrigen  = esDirSkill ? path.join(origenAbsoluto, 'SKILL.md') : origenAbsoluto;
     const versionBackup = opciones.versionAnterior || opciones.versionActual || 'previa';
 
+    // C-3: los artefactos de gobernanza evolved (AUDITORIA.md + diffs de
+    // reconciliación) se enraízan en la base del install. En scope GLOBAL
+    // (~/.claude, ~/.codex) usan `.swl-evolved-backups/` para NO crear un dir
+    // `.planning/` de proyecto dentro del dir de config global; en proyecto
+    // usan `.planning/` (gobernanza.md).
+    const govBase = rutas.base || process.cwd();
+    const govSubdir = opciones.esGlobal ? '.swl-evolved-backups' : '.planning';
+    const reconcileDir = govSubdir === '.planning'
+      ? path.join(govBase, '.planning', 'evolution', 'reconcile')
+      : path.join(govBase, '.swl-evolved-backups', 'reconcile');
+    const auditEvolved = (e) => auditarEscritura({ ...e, cwd: govBase, subdir: govSubdir });
+
     // MEDIO (nemesis O6): dir de skill existe pero sin SKILL.md = instalación
     // corrupta. Diagnóstico explícito (cae al flujo normal, no rompe invariante).
     if (esDirSkill && !fs.existsSync(cmpDestino)) {
@@ -1193,7 +1206,7 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
         const backup = crearBackup(process.cwd(), cmpDestino, versionBackup);
         if (!backup.respaldado) {
           console.log(`  ⚠ Backup falló (${backup.error || 'desconocido'}) para ${nombreArchivo} — merge abortado, original preservado`);
-          auditarEscritura({ archivo: path.relative(process.cwd(), cmpDestino), clasificacion: 'A', accion: 'preserve', hashAntes, evidencia: `backup falló: ${backup.error || 'desconocido'}` });
+          auditEvolved({ archivo: path.relative(process.cwd(), cmpDestino), clasificacion: 'A', accion: 'preserve', hashAntes, evidencia: `backup falló: ${backup.error || 'desconocido'}` });
           return { instalado: false, evolucionado: true, destino, error: 'backup-failed' };
         }
         const backupPath = backup.rutaBackup;
@@ -1202,8 +1215,8 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
         if (opciones.estado) {
           registrarBackup(opciones.estado, { rutaOriginal: cmpDestino, rutaBackup: backupPath, version: versionBackup, evolucionado: true });
         }
-        // Diff centralizado bajo el root del install (no adyacente al comando/skill).
-        const reconcileDir = path.join(rutas.base || process.cwd(), '.planning', 'evolution', 'reconcile');
+        // Diff centralizado bajo el root del install (reconcileDir calculado arriba,
+        // scope-aware: .planning en proyecto, .swl-evolved-backups en global).
         const merge = mergeEvolved(cmpDestino, cmpOrigen, opciones.versionActual || '', { diffDir: reconcileDir });
         if (merge.merged && merge.diffPath) {
           console.log(`    ⊕ Diff generado: ${path.relative(process.cwd(), merge.diffPath)} (${merge.diffsCount} mutaciones)`);
@@ -1218,7 +1231,7 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
             recursosActualizados = true;
           } catch (e) { console.log(`    ⚠ No se pudieron actualizar recursos del skill: ${e.message}`); }
         }
-        const aud = auditarEscritura({ archivo: path.relative(process.cwd(), cmpDestino), clasificacion: 'A', accion: 'merge', hashAntes, backupPath, evidencia: strategy.reason });
+        const aud = auditEvolved({ archivo: path.relative(process.cwd(), cmpDestino), clasificacion: 'A', accion: 'merge', hashAntes, backupPath, evidencia: strategy.reason });
         if (!aud.registrado) console.log(`    ⚠ Auditoría no registrada: ${aud.error}`);
         return { instalado: recursosActualizados, evolucionado: true, destino };
       }
@@ -1236,12 +1249,12 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
           let backupOk = false;
           try { copiarDirectorio(destino, backupDir); backupOk = true; } catch (e) { console.log(`  ⚠ Backup de directorio falló (${e.message})`); }
           if (!backupOk) {
-            auditarEscritura({ archivo: path.relative(process.cwd(), destino), clasificacion: 'B', accion: 'preserve', hashAntes, evidencia: 'backup de directorio falló' });
+            auditEvolved({ archivo: path.relative(process.cwd(), destino), clasificacion: 'B', accion: 'preserve', hashAntes, evidencia: 'backup de directorio falló' });
             return { instalado: false, evolucionado: true, destino, error: 'backup-failed' };
           }
           console.log(`  ⇪ Actualizado (shipped-evolved): ${nombreArchivo} — ${strategy.reason}`);
           if (opciones.estado) registrarBackup(opciones.estado, { rutaOriginal: destino, rutaBackup: backupDir, version: versionBackup, evolucionado: true });
-          const aud = auditarEscritura({ archivo: path.relative(process.cwd(), cmpDestino), clasificacion: 'B', accion: 'overwrite', hashAntes, hashDespues, backupPath: backupDir, evidencia: strategy.reason });
+          const aud = auditEvolved({ archivo: path.relative(process.cwd(), cmpDestino), clasificacion: 'B', accion: 'overwrite', hashAntes, hashDespues, backupPath: backupDir, evidencia: strategy.reason });
           if (!aud.registrado) console.log(`    ⚠ Auditoría no registrada: ${aud.error}`);
           copiarDirectorio(origenAbsoluto, destino); // overwrite dir completo (recursos + SKILL.md)
           return { instalado: true, evolucionado: true, destino };
@@ -1252,7 +1265,7 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
         // 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`);
-          auditarEscritura({ archivo: path.relative(process.cwd(), cmpDestino), clasificacion: 'B', accion: 'preserve', hashAntes, evidencia: `backup falló: ${backup.error || 'desconocido'}` });
+          auditEvolved({ archivo: path.relative(process.cwd(), cmpDestino), clasificacion: 'B', accion: 'preserve', hashAntes, evidencia: `backup falló: ${backup.error || 'desconocido'}` });
           return { instalado: false, evolucionado: true, destino, error: 'backup-failed' };
         }
         const backupPath = backup.rutaBackup;
@@ -1260,7 +1273,7 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
         if (opciones.estado) {
           registrarBackup(opciones.estado, { rutaOriginal: cmpDestino, rutaBackup: backupPath, version: versionBackup, evolucionado: true });
         }
-        const aud = auditarEscritura({ archivo: path.relative(process.cwd(), cmpDestino), clasificacion: 'B', accion: 'overwrite', hashAntes, hashDespues, backupPath, evidencia: strategy.reason });
+        const aud = auditEvolved({ archivo: path.relative(process.cwd(), cmpDestino), clasificacion: 'B', accion: 'overwrite', hashAntes, hashDespues, backupPath, evidencia: strategy.reason });
         if (!aud.registrado) console.log(`    ⚠ Auditoría no registrada: ${aud.error}`);
         forzarEscrituraEvolved = true; // bypassa la verificación de colisión sin --force
       }

package/scripts/lib/audit-evolved.js

@@ -34,12 +34,17 @@ const HEADER = '# AUDITORIA\n\n' +
  * @param {string} [e.backupPath]   - Ruta del backup creado antes de escribir.
  * @param {string} [e.evidencia]    - Razón/criterio que clasificó A vs B.
  * @param {string} [e.timestamp]    - ISO; default `new Date().toISOString()`.
- * @param {string} [e.cwd]          - Raíz del proyecto; default process.cwd().
+ * @param {string} [e.cwd]          - Raíz de la operación; default process.cwd().
+ * @param {string} [e.subdir]       - Subdir bajo `cwd` donde vive AUDITORIA.md.
+ *   Default `.planning` (scope proyecto, gobernanza.md). En scope global/runtime
+ *   (~/.claude, ~/.codex) usar `.swl-evolved-backups` para NO crear un dir
+ *   `.planning/` de proyecto dentro del dir de config global (C-3 Fase 16.1).
  * @returns {{ registrado: boolean, ruta: string }}
  */
 function auditarEscritura(e) {
   const cwd = e.cwd || process.cwd();
-  const ruta = path.join(cwd, '.planning', 'AUDITORIA.md');
+  const subdir = e.subdir || '.planning';
+  const ruta = path.join(cwd, subdir, 'AUDITORIA.md');
   try {
     fs.mkdirSync(path.dirname(ruta), { recursive: true });
     if (!fs.existsSync(ruta)) fs.writeFileSync(ruta, HEADER, 'utf8');

package/scripts/lib/claude-sessions.js

@@ -27,6 +27,7 @@ const TOLERANCIA_FUTURO_MS = 60 * 1000;
 
 // Tabla de precios por modelo (USD por token)
 const PRECIOS_MODELO = {
+  'claude-opus-4-8': { entrada: 15 / 1_000_000, salida: 75 / 1_000_000 },
   'claude-opus-4-7': { entrada: 15 / 1_000_000, salida: 75 / 1_000_000 },
   'claude-opus-4-6': { entrada: 15 / 1_000_000, salida: 75 / 1_000_000 },
   'claude-sonnet-4-6': { entrada: 3 / 1_000_000, salida: 15 / 1_000_000 },

package/scripts/lib/manifiestos.js

@@ -93,7 +93,7 @@ function resolverPerfil(nombrePerfil, opciones = {}) {
 
     // Verificar soporte de target
     if (opciones.target && modulo.targets && !modulo.targets.includes(opciones.target)) {
-      warnings.push(`Módulo "${nombreModulo}" no soporta target "${opciones.target}", omitido`);
+      warnings.push(`Módulo "${nombreModulo}" no declarado para target "${opciones.target}" (omitido; declarado para: ${modulo.targets.join(', ')})`);
       continue;
     }
 

package/scripts/lib/tool-cost-analyzer.js

@@ -23,6 +23,7 @@ const DB_PATH = path.join(os.homedir(), '.claude', 'usage.db');
 
 // Precios estimados por 1M tokens (USD) — actualizados a 2026-04-17
 const PRECIOS = {
+  'claude-opus-4-8':    { input: 15.00, output: 75.00, cache_read: 1.50,  cache_creation: 18.75 },
   'claude-opus-4-7':    { input: 15.00, output: 75.00, cache_read: 1.50,  cache_creation: 18.75 },
   'claude-opus-4-6':    { input: 15.00, output: 75.00, cache_read: 1.50,  cache_creation: 18.75 },
   'claude-sonnet-4-6':  { input:  3.00, output: 15.00, cache_read: 0.30,  cache_creation:  3.75 },

package/scripts/publicar.js

@@ -16,7 +16,6 @@ const { execFileSync, spawnSync } = require('child_process');
 const fs   = require('fs');
 const path = require('path');
 const os   = require('os');
-const readline = require('readline');
 
 const {
   NOMBRE_GITHUB_MIRROR: GITHUB_NAME,
@@ -32,6 +31,32 @@ const {
 const ROOT     = path.resolve(__dirname, '..');
 const PKG_PATH = path.join(ROOT, 'package.json');
 
+// --- Log de la corrida (.planning/logs/publish-<version>-<ts>.log) -----------
+// Captura stdout+stderr del publish para diagnóstico: npm v10 NO escribe el
+// stdout de un script fallido (prepublishOnly/test:release) en su debug log,
+// así que sin esto el test que rompe el publish queda invisible. Tee: eco a
+// consola + archivo persistente.
+let LOG_PATH = null;
+function iniciarLog(version) {
+  try {
+    const dir = path.join(ROOT, '.planning', 'logs');
+    fs.mkdirSync(dir, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, '-');
+    LOG_PATH = path.join(dir, `publish-${version}-${ts}.log`);
+    // Escritura SÍNCRONA (writeFileSync/appendFileSync): un createWriteStream
+    // async + process.exit() inmediato perdía el buffer sin volcarlo a disco
+    // (dejaba el log vacío). appendFileSync vacía en cada llamada.
+    fs.writeFileSync(LOG_PATH, `# publish ${version} — ${new Date().toISOString()}\n# argv: ${process.argv.slice(2).join(' ')}\n\n`);
+  } catch (err) {
+    process.stderr.write(`[publicar] no se pudo abrir log: ${String(err.message).slice(0, 120)}\n`);
+    LOG_PATH = null;
+  }
+}
+function logWrite(text) {
+  if (LOG_PATH && text) { try { fs.appendFileSync(LOG_PATH, text); } catch { /* best-effort */ } }
+}
+function cerrarLog() { /* no-op: appendFileSync ya volcó todo a disco */ }
+
 /**
  * Resuelve el binario de npm a invocar. Usa node + npm-cli.js cuando es
  * posible para evitar shell:true en Windows (mismo enfoque que la lib
@@ -60,15 +85,19 @@ function npmExec(args, opts = {}) {
 }
 
 /**
- * Variante de npmExec que captura stderr para detección posterior de errores
- * estructurados (ej: EOTP). stdout sigue heredado (live-streaming visible al
- * usuario) y stderr se pipea a un buffer + se ecoa a process.stderr al final.
+ * Variante de npmExec que captura stdout+stderr para (a) detección de errores
+ * estructurados (ej: EOTP) y (b) persistencia en el log de la corrida
+ * (`iniciarLog`). Ambos streams se pipean, se ecoan a consola al terminar y se
+ * vuelcan al log — así el stdout del script que rompe el publish (test:release)
+ * queda registrado. Trade-off: la salida del prepublish aparece al finalizar el
+ * spawn (no en vivo), por eso se imprime un aviso antes.
  *
  * Retorna { status, stderr } sin lanzar — el caller inspecciona el status.
  */
 function npmSpawnCaptureStderr(args, opts = {}) {
   const defaults = { cwd: ROOT, timeout: 300_000, env: process.env };
-  const merged = { ...defaults, ...opts, stdio: ['inherit', 'inherit', 'pipe'] };
+  const merged = { ...defaults, ...opts, stdio: ['inherit', 'pipe', 'pipe'] };
+  process.stderr.write('[publicar] ejecutando npm (incluye prepublish/test:release; salida completa al finalizar y en el log)...\n');
   let res;
   if (NPM_CLI_JS) {
     res = spawnSync(process.execPath, [NPM_CLI_JS, ...args], merged);
@@ -76,9 +105,13 @@ function npmSpawnCaptureStderr(args, opts = {}) {
     const bin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
     res = spawnSync(bin, args, merged);
   }
+  const stdout = res.stdout ? String(res.stdout) : '';
   const stderr = res.stderr ? String(res.stderr) : '';
-  // Ecoar stderr al usuario para que vea el diagnóstico de npm aunque se capturó.
+  // Eco a consola + volcado al log (stdout primero, luego stderr).
+  if (stdout) process.stdout.write(stdout);
   if (stderr) process.stderr.write(stderr);
+  logWrite(stdout);
+  logWrite(stderr);
   return { status: res.status, signal: res.signal, stderr, error: res.error };
 }
 
@@ -97,84 +130,35 @@ function esErrorOTP(stderr) {
 }
 
 /**
- * Solicita una OTP al usuario via stdin (readline síncrono).
- * Retorna la OTP normalizada (string de 6 dígitos) o null si:
- *   - stdin no es TTY (CI, pipe) → no se puede pedir interactivamente
- *   - el usuario cancela con Ctrl+C / línea vacía
- *   - el formato no es válido (no 6 dígitos)
- *
- * El caller debe manejar el caso null como "fallback a guía manual".
- */
-function solicitarOTPInteractiva() {
-  if (!process.stdin.isTTY) {
-    process.stderr.write('[publicar] stdin no es TTY: no se puede pedir OTP interactivamente.\n');
-    process.stderr.write('[publicar] Configurar NPM_CONFIG_OTP=<otp> antes de invocar este script.\n');
-    return null;
-  }
-
-  const rl = readline.createInterface({ input: process.stdin, output: process.stderr });
-  // questionSync vía promesa NO funciona aquí — el script es síncrono.
-  // Usamos un truco: readline es async-only, así que dejamos al usuario
-  // el manejo bloqueante leyendo línea por línea con readSync vía read-int.
-  // Pero readline no expone modo síncrono. Alternativa: leer de stdin con
-  // fd 0 + readSync. En Windows con TTY funciona; en Linux idem.
-  try {
-    process.stderr.write('\nNPM requiere OTP (2FA). Ingresa el código de 6 dígitos de tu autenticador: ');
-    const otp = leerLineaStdinSync().trim();
-    rl.close();
-    if (!/^\d{6}$/.test(otp)) {
-      process.stderr.write(`\n[publicar] OTP inválida: se esperan 6 dígitos, se recibió: "${otp.slice(0, 20)}"\n`);
-      return null;
-    }
-    return otp;
-  } catch (err) {
-    rl.close();
-    process.stderr.write(`\n[publicar] error leyendo OTP: ${String(err.message).slice(0, 120)}\n`);
-    return null;
-  }
-}
-
-/**
- * Lectura síncrona de una línea de stdin. Necesario porque readline solo
- * expone API asíncrona, pero todo el flujo de publicar.js es síncrono.
- * Lee byte por byte hasta encontrar newline o EOF.
+ * Ejecuta npm con stdio HEREDADO (interactivo): npm escribe directo a la
+ * terminal y lee de stdin, de modo que su flujo de 2FA NATIVO funciona —
+ * prompt de OTP TOTP O auth web/passkey ("abrir URL y seleccionar la llave"),
+ * según el método 2FA de la cuenta. Retorna el exit status sin lanzar.
+ * (A1: soporte passkey/WebAuthn, no solo TOTP.)
  */
-function leerLineaStdinSync() {
-  const BUFFER_SIZE = 256;
-  const buf = Buffer.alloc(BUFFER_SIZE);
-  let line = '';
-  while (true) {
-    let bytesRead;
-    try {
-      bytesRead = fs.readSync(0, buf, 0, BUFFER_SIZE, null);
-    } catch (err) {
-      // EAGAIN en stdin no-bloqueante: poco común en TTY, pero defensivo.
-      if (err.code === 'EAGAIN') continue;
-      throw err;
-    }
-    if (bytesRead === 0) break; // EOF
-    const chunk = buf.slice(0, bytesRead).toString('utf-8');
-    const nlIdx = chunk.indexOf('\n');
-    if (nlIdx >= 0) {
-      line += chunk.slice(0, nlIdx);
-      break;
-    }
-    line += chunk;
+function npmExecInherit(args, opts = {}) {
+  const merged = { cwd: ROOT, timeout: 600_000, env: process.env, ...opts, stdio: 'inherit' };
+  let res;
+  if (NPM_CLI_JS) {
+    res = spawnSync(process.execPath, [NPM_CLI_JS, ...args], merged);
+  } else {
+    const bin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+    res = spawnSync(bin, args, merged);
   }
-  return line.replace(/\r$/, ''); // Windows envía \r\n
+  return res.status;
 }
 
 /**
  * Ejecuta un `npm publish` con soporte automático de OTP (2FA).
  *
  * Flujo:
- *   1. Si NPM_CONFIG_OTP está definida en el entorno, se usa directamente
- *      (npm la lee automáticamente — no hay que pasarla como flag).
- *   2. Si el publish falla con EOTP/one-time password, se intenta solicitar
- *      la OTP interactivamente y reintentar con --ignore-scripts (los
- *      scripts pre-publish ya pasaron en el primer intento).
- *   3. Si no se puede obtener OTP (no TTY o usuario cancela), reporta el
- *      error y retorna false.
+ *   1. Si NPM_CONFIG_OTP está definida en el entorno (o hay token Automation),
+ *      se usa directamente y el intento 1 publica sin interacción.
+ *   2. Si el publish falla con EOTP/one-time password y stdin es TTY, se
+ *      reintenta con stdio HEREDADO para que npm conduzca su 2FA NATIVO —
+ *      OTP TOTP O passkey/WebAuthn (navegador), según la cuenta — con
+ *      --ignore-scripts (los pre-publish ya pasaron en el intento 1).
+ *   3. Si stdin no es TTY (CI sin OTP), reporta el error y retorna false.
  *
  * Retorna: { ok: boolean, stderr: string }
  *
@@ -192,24 +176,23 @@ function ejecutarPublishConOTP(args, opts = {}) {
     return { ok: false, stderr: intento1.stderr };
   }
 
-  // Es EOTP. Intentar solicitar OTP interactivamente.
+  // Es EOTP — 2FA requerida. npm soporta varios métodos: OTP TOTP (6 dígitos)
+  // O passkey/WebAuthn vía navegador ("abrir URL y seleccionar la llave").
+  // Forzar un prompt de TOTP rompe a los usuarios con passkey (A1). En su lugar
+  // se reintenta con stdio HEREDADO para que npm conduzca su 2FA NATIVO —
+  // funcione cual sea el método configurado en la cuenta.
   process.stderr.write('\n[publicar] npm rechazó el publish con EOTP (2FA requerida).\n');
-  const otp = solicitarOTPInteractiva();
-  if (!otp) {
-    process.stderr.write('[publicar] No se obtuvo OTP. Aborta. Reintentar con:\n');
-    process.stderr.write(`  NPM_CONFIG_OTP=<otp> node scripts/publicar.js ${process.argv.slice(2).join(' ')}\n`);
+  if (!process.stdin.isTTY) {
+    process.stderr.write('[publicar] stdin no es TTY: no se puede completar 2FA interactivo.\n');
+    process.stderr.write('[publicar] Opciones: exportar NPM_CONFIG_OTP=<otp>, o usar un token Automation (omite 2FA).\n');
     return { ok: false, stderr: intento1.stderr };
   }
-
-  // Reintento con OTP via env + --ignore-scripts (los pre-publish ya pasaron).
-  process.stderr.write('\n[publicar] Reintentando publish con OTP recibida...\n');
-  const envConOTP = { ...(opts.env || process.env), NPM_CONFIG_OTP: otp };
+  // Reintento interactivo: --ignore-scripts porque los pre-publish ya pasaron en
+  // el intento 1 (el prepack limpió el árbol; no se re-ejecuta test:release).
+  process.stderr.write('\n[publicar] Reintentando con el 2FA interactivo nativo de npm (OTP o passkey)...\n');
   const argsConIgnore = args.includes('--ignore-scripts') ? args : [...args, '--ignore-scripts'];
-  const intento2 = npmSpawnCaptureStderr(argsConIgnore, { ...opts, env: envConOTP });
-  if (intento2.status === 0) {
-    return { ok: true, stderr: intento2.stderr };
-  }
-  return { ok: false, stderr: intento2.stderr };
+  const status = npmExecInherit(argsConIgnore, opts);
+  return { ok: status === 0, stderr: status === 0 ? '' : 'fallo en reintento interactivo de 2FA' };
 }
 
 function leerPkg() {
@@ -482,6 +465,7 @@ function reportarResultado(pkg, opts, npmjsOk, githubOk) {
 function main() {
   const opts = parsearArgs(process.argv.slice(2));
   const pkg  = leerPkg();
+  iniciarLog(pkg.version);
   imprimirEncabezado(pkg.version, opts.dryRun);
   avisarSiHayCambiosSinCommit(opts.dryRun);
 
@@ -489,6 +473,8 @@ function main() {
   const githubOk = opts.soloNpmjs  ? true : publicarGitHub(pkg, opts.dryRun);
 
   reportarResultado(pkg, opts, npmjsOk, githubOk);
+  if (LOG_PATH) process.stdout.write(`\nLog de la corrida: ${path.relative(ROOT, LOG_PATH).replace(/\\/g, '/')}\n`);
+  cerrarLog();
   process.exit(npmjsOk && githubOk ? 0 : 1);
 }
 

package/scripts/remediar-evolved-instaladas.js

@@ -136,7 +136,10 @@ function remediar({ target, apply = false } = {}) {
   target = expandirTarget(target);
   const manifiesto = cargarManifiesto();
   const ts = new Date().toISOString().replace(/[:.]/g, '-');
-  const reconcileDir = path.join(target, '.planning', 'evolution', 'reconcile');
+  // El target es un dir de config runtime (~/.claude, ~/.codex), NO un proyecto:
+  // los artefactos de gobernanza evolved van bajo `.swl-evolved-backups/` (donde
+  // ya viven los backups), sin crear un `.planning/` de proyecto ahí (C-3).
+  const reconcileDir = path.join(target, '.swl-evolved-backups', 'reconcile');
   const resumen = { target, A: [], B: [], errores: [], reconcileDir };
 
   for (const item of escanear(target)) {
@@ -181,7 +184,7 @@ function remediar({ target, apply = false } = {}) {
         const hashFuente = canonicalHash(fs.readFileSync(fuenteAbs, 'utf8')); // antes del copy
         const backupPath = backupSimple(target, item.archivo, ts);            // backup PRECEDE al overwrite
         fs.copyFileSync(fuenteAbs, item.archivo); // fuente limpio (sin evolved-*) → descongelado
-        auditarEscritura({ archivo: item.sourceRel, clasificacion: 'B', accion: 'overwrite', hashAntes: instaladoHash, hashDespues: hashFuente, backupPath, evidencia: `remediación: ${evidencia}` });
+        auditarEscritura({ archivo: item.sourceRel, clasificacion: 'B', accion: 'overwrite', hashAntes: instaladoHash, hashDespues: hashFuente, backupPath, evidencia: `remediación: ${evidencia}`, cwd: target, subdir: '.swl-evolved-backups' });
       } catch (e) { resumen.errores.push({ archivo: item.sourceRel, error: e.message }); continue; }
     }
     resumen.B.push({ archivo: item.sourceRel, from: ev.from, razon: evidencia });
@@ -224,7 +227,7 @@ function imprimir(r, apply) {
     for (const e of r.errores) process.stdout.write(`  ! ${e.archivo}: ${e.error}\n`);
   }
   if (apply && r.A.length) process.stdout.write(`\nDiffs de reconciliación (revisión upstream): ${path.relative(r.target, r.reconcileDir).replace(/\\/g, '/')}/INDEX.md\n`);
-  if (!apply && r.B.length) process.stdout.write(`\n→ Para aplicar: agregar --apply (backups en <target>/.swl-evolved-backups/, diffs centralizados en .planning/evolution/reconcile/).\n`);
+  if (!apply && r.B.length) process.stdout.write(`\n→ Para aplicar: agregar --apply (backups, diffs y AUDITORIA centralizados en <target>/.swl-evolved-backups/).\n`);
 }
 
 if (require.main === module) {