@saulwade/swl-ses 2.3.1 → 2.4.2

package/scripts/doctor.js

@@ -10,7 +10,7 @@
 const fs = require('fs');
 const path = require('path');
 
-const { detectarRuntimes, detectarInstalacionesDuales } = require('./lib/detectar-runtime');
+const { detectarRuntimes, detectarInstalacionesDuales, esDirGlobalDeAlgunRuntime, scopesReales } = require('./lib/detectar-runtime');
 const { cargarEstado, verificarIntegridad } = require('./lib/estado');
 const { verificarHooks, repararHooks, rutaSettings, cargarHooksConfig, desregistrarHooks, esHookSWL, verificarOptimizaciones, registrarOptimizaciones, validarEstructuraSettings } = require('./lib/hooks-settings');
 const {
@@ -106,7 +106,10 @@ async function doctor(opciones = {}) {
   try {
     const runtimesParaDrift = detectarRuntimes();
     for (const runtime of runtimesParaDrift) {
-      for (const dir of [runtime.global, path.resolve(runtime.local)]) {
+      // Dedup + guard anti-fantasma: desde HOME, global y local colapsan al
+      // mismo dir (reporte doble) o el local resuelve al GLOBAL de otro
+      // runtime (drift "proyecto" espurio). Caso real doctor 2026-07-03.
+      for (const { dir, esGlobal } of scopesReales(runtime)) {
         if (!fs.existsSync(dir)) continue;
         const estado = cargarEstado(dir);
         if (!estado || !estado.versionSistema) continue;
@@ -115,7 +118,7 @@ async function doctor(opciones = {}) {
           driftsDetectados.push({
             runtime: runtime.nombre,
             runtimeId: runtime.id,
-            scope: dir === runtime.global ? 'global' : 'proyecto',
+            scope: esGlobal ? 'global' : 'proyecto',
             dir,
             versionInstalada: estado.versionSistema,
             perfil: estado.perfil || 'desconocido',
@@ -259,13 +262,10 @@ async function doctor(opciones = {}) {
 
   // 5. Verificar estado de instalación por runtime
   for (const runtime of runtimes) {
-    // Deduplicar: cuando global y local resuelven al mismo path (ej: running desde home dir)
-    const dirsRaw = [runtime.global, path.resolve(runtime.local)];
-    const dirs = [...new Set(dirsRaw)];
-    for (const dir of dirs) {
+    // Deduplicar + descartar locales que resuelven al global de otro runtime
+    // (ej: doctor corrido desde el home dir)
+    for (const { dir, esGlobal } of scopesReales(runtime)) {
       if (!fs.existsSync(dir)) continue;
-
-      const esGlobal = dir === runtime.global;
       const estado = cargarEstado(dir);
       if (estado) {
         const { integro, problemas } = verificarIntegridad(estado);
@@ -379,11 +379,7 @@ async function doctor(opciones = {}) {
   // Sub-fase 12 v1.5.0: deduplicar paths cuando cwd === homedir (runtime.local
   // y runtime.global colapsan al mismo directorio) — evita reporte doble.
   for (const runtime of runtimes) {
-    const dirsUnicos = Array.from(new Set([
-      path.resolve(runtime.global),
-      path.resolve(runtime.local),
-    ]));
-    for (const dir of dirsUnicos) {
+    for (const { dir } of scopesReales(runtime)) {
     if (!fs.existsSync(dir)) continue;
     const estado = cargarEstado(dir);
     if (!estado || !estado.perfil) continue;
@@ -559,12 +555,20 @@ async function doctor(opciones = {}) {
   for (const runtime of runtimes) {
     const dir = path.resolve(runtime.local);
     if (!fs.existsSync(dir)) continue;
+    // Local que resuelve al global de OTRO runtime = scope fantasma (ver scopesReales)
+    if (esDirGlobalDeAlgunRuntime(dir) && dir !== path.resolve(runtime.global)) continue;
     const estado = cargarEstado(dir);
     if (!estado) continue;
 
     const settingsPath = rutaSettings(runtime, dir);
     if (fs.existsSync(settingsPath)) {
-      const structResult = validarEstructuraSettings(settingsPath);
+      // Cursor usa hooks.json con eventos camelCase propios y entradas PLANAS
+      // ({command, type}) — el esquema Claude produce falsos errores
+      // ("afterFileEdit: evento no reconocido", "[0].hooks debe ser array").
+      // Codex también usa hooks.json pero con FORMA Claude ({matcher,
+      // hooks:[...]}, eventos PascalCase) — ver transformadores/codex.js.
+      const formatoHooks = runtime.id === 'cursor' ? 'plano' : 'claude';
+      const structResult = validarEstructuraSettings(settingsPath, { formatoHooks });
       if (structResult.ok) {
         console.log(formatearPaso(`Estructura settings ${runtime.nombre}`, 'Formato válido'));
         ok++;
@@ -624,8 +628,7 @@ async function doctor(opciones = {}) {
 
   // 8. Verificar componentes externos
   for (const runtime of runtimes) {
-    const dirs = [runtime.global, path.resolve(runtime.local)];
-    for (const dir of dirs) {
+    for (const { dir } of scopesReales(runtime)) {
       if (!fs.existsSync(dir)) continue;
       const estado = cargarEstado(dir);
       if (estado && estado.componentesExternos && estado.componentesExternos.length > 0) {
@@ -712,6 +715,11 @@ async function doctor(opciones = {}) {
       } else {
         console.log(`  ${reparados} reparado(s), ${color.rojo(`${fallos} fallo(s)`)}.`);
       }
+      // Las reparaciones no se re-verifican en esta corrida: honestidad sobre
+      // el alcance (caso repair-loop 2026-07-03 — un falso positivo del check
+      // se "reparaba" y reaparecía indefinidamente).
+      console.log(`  ${color.dim('Re-ejecuta `doctor` para confirmar. Si el MISMO problema reaparece tras reparar,')}`);
+      console.log(`  ${color.dim('es un falso positivo del check (repórtalo) — no falta de reparación.')}`);
     } else {
       console.log(`  ${color.dim('Reparación cancelada. Usa --force para reparar sin confirmar.')}`);
     }

package/scripts/instalador.js

@@ -26,6 +26,7 @@ const { obtenerTransformador } = require('./lib/transformadores');
 const {
   esProtegido,
   crearBackup,
+  rutaBackupSegura,
   registrarBackup,
   limpiarBackups,
   mergeInstintos,
@@ -1245,7 +1246,9 @@ function instalarArchivo(archivo, rutas, runtime, opciones = {}) {
           // ALTO (nemesis O6): respaldar el DIRECTORIO COMPLETO (recursos incluidos)
           // antes de sobrescribir — el usuario pudo modificar recursos/ aunque no
           // tocara el SKILL.md. Overwrite controlado en-bloque (no fall-through).
-          const backupDir = path.join(process.cwd(), '.planning', 'backups', `v${versionBackup}`, path.relative(process.cwd(), destino));
+          // rutaBackupSegura contiene el backup dentro del dir versionado incluso
+          // cuando destino está fuera del cwd (install --global — bug 2026-07-03).
+          const backupDir = rutaBackupSegura(process.cwd(), versionBackup, destino);
           let backupOk = false;
           try { copiarDirectorio(destino, backupDir); backupOk = true; } catch (e) { console.log(`  ⚠ Backup de directorio falló (${e.message})`); }
           if (!backupOk) {

package/scripts/lib/detectar-runtime.js

@@ -151,6 +151,48 @@ const RUNTIMES = {
   },
 };
 
+/**
+ * ¿El directorio dado es el dir GLOBAL de alguno de los runtimes conocidos?
+ *
+ * Un dir global jamás debe interpretarse como instalación "de proyecto" de
+ * otro runtime: con cwd en el HOME del usuario, todos los `runtime.local`
+ * relativos (.claude, .cursor, .codex, …) resuelven dentro del HOME y
+ * colisionan con los globales — el caso más dañino es OpenClaude, cuyo
+ * local `.claude` colisiona con el global de Claude Code.
+ *
+ * @param {string} dir - Ruta absoluta o relativa a evaluar.
+ * @returns {boolean}
+ */
+function esDirGlobalDeAlgunRuntime(dir) {
+  const objetivo = path.resolve(dir);
+  for (const config of Object.values(RUNTIMES)) {
+    if (path.resolve(config.global) === objetivo) return true;
+  }
+  return false;
+}
+
+/**
+ * Scopes REALES de un runtime: [global, proyecto] deduplicados y sin
+ * fantasmas. Con cwd en el HOME, el local relativo (.claude/.cursor/.codex)
+ * resuelve al dir GLOBAL propio (duplicado) o al de OTRO runtime (scope
+ * "proyecto" espurio — p.ej. el local de OpenClaude colisiona con el global
+ * de Claude Code, y un uninstall de ese "proyecto" borraría el global).
+ *
+ * Consumidores: doctor, actualizar, TUI (inspect/uninstall/update/welcome).
+ *
+ * @param {object} runtime - Config de RUNTIMES (con .global y .local).
+ * @returns {Array<{dir: string, esGlobal: boolean}>}
+ */
+function scopesReales(runtime) {
+  const globalAbs = path.resolve(runtime.global);
+  const localAbs = path.resolve(runtime.local);
+  const scopes = [{ dir: globalAbs, esGlobal: true }];
+  if (localAbs !== globalAbs && !esDirGlobalDeAlgunRuntime(localAbs)) {
+    scopes.push({ dir: localAbs, esGlobal: false });
+  }
+  return scopes;
+}
+
 /**
  * Detecta qué runtimes están instalados en el sistema
  */
@@ -174,6 +216,13 @@ function detectarRuntimes() {
     // Si este runtime comparte su directorio local con otro (ej: openclaude comparte .claude/ con claude),
     // solo considerarlo instalado localmente si el estado de instalación declara explícitamente este target.
     let localEfectivo = localExiste;
+
+    // Guard universal: el dir global de un runtime NUNCA es una instalación de
+    // proyecto. Con cwd en el HOME, `<cwd>/.claude` resuelve al GLOBAL de
+    // Claude Code y la detección lo trataba como "proyecto" de OpenClaude —
+    // produciendo falso "instalación duplicada", 47 hooks "faltantes" y un
+    // repair-loop (caso real doctor 2026-07-03).
+    if (esDirGlobalDeAlgunRuntime(localAbs)) localEfectivo = false;
     const comparte = (localUsadoPor[localAbs] || []).length > 1;
     if (comparte && localExiste && !globalExiste) {
       // Revisar el estado de instalación para ver si el target coincide
@@ -293,6 +342,13 @@ function detectarInstalacionesDuales(runtimeId, opciones = {}) {
     return { hayConflicto: false, global: false, local: false, globalDir, localDir };
   }
 
+  // El dir global de CUALQUIER runtime no puede ser el lado "proyecto" del
+  // conflicto: con cwd en HOME, el local de OpenClaude (.claude) resuelve al
+  // global de Claude Code y se reportaba "duplicado global+proyecto" espurio.
+  if (esDirGlobalDeAlgunRuntime(localDir)) {
+    return { hayConflicto: false, global: Boolean(require('./estado').cargarEstado(globalDir)), local: false, globalDir, localDir };
+  }
+
   const estadoGlobal = cargarEstado(globalDir);
   const estadoLocal = cargarEstado(localDir);
 
@@ -337,6 +393,8 @@ function listarRuntimesInstalables() {
 module.exports = {
   RUNTIMES,
   detectarRuntimes,
+  esDirGlobalDeAlgunRuntime,
+  scopesReales,
   detectarInstalacionesDuales,
   obtenerRuntime,
   calcularRutas,

package/scripts/lib/expandir-targets.js

@@ -1,71 +1,71 @@
-'use strict';
-
-/**
- * Expansión de --target (CSV) y --all-runtimes para multi-target install.
- *
- * ADR-0019 Sub-fase 2.5.
- *
- * Extraído de bin/swl-ses.js para permitir tests unitarios. NUNCA debe tener
- * side effects fuera de logging — solo manipula la lista de strings.
- *
- * @module scripts/lib/expandir-targets
- */
-
-const { listarRuntimesInstalables, RUNTIMES } = require('./detectar-runtime');
-
-/**
- * Expande las opciones del CLI a un array de target IDs.
- *
- * Reglas:
- *  - `all_runtimes` tiene prioridad sobre `target`. Si ambos vienen, se loggea
- *    aviso (vía `logger.warn`) y se usa `all_runtimes`.
- *  - `target='a,b,c'` → ['a','b','c'].
- *  - `target='claude'` → ['claude'].
- *  - Sin nada → ['claude'] (default histórico, backward-compat).
- *  - Duplicados se deduplican preservando el primer orden.
- *  - Targets desconocidos se omiten con aviso (logger.warn).
- *
- * @param {object} opciones - Objeto con `target` (string|undefined) y `all_runtimes` (bool).
- * @param {object} [logger] - Sustituible para tests. Default console.
- * @returns {{ targets: string[], omitidos: string[], errores: string[] }}
- */
-function expandirTargets(opciones, logger) {
-  const log = logger || console;
-  const omitidos = [];
-  const errores = [];
-
-  let candidatos;
-  if (opciones.all_runtimes) {
-    if (opciones.target && typeof opciones.target === 'string') {
-      log.warn && log.warn('[expandir-targets] --all-runtimes tiene prioridad sobre --target; se ignora --target.');
-    }
-    candidatos = listarRuntimesInstalables();
-  } else if (typeof opciones.target === 'string' && opciones.target.includes(',')) {
-    candidatos = opciones.target.split(',').map(s => s.trim()).filter(Boolean);
-  } else if (typeof opciones.target === 'string' && opciones.target.length > 0) {
-    candidatos = [opciones.target.trim()];
-  } else {
-    candidatos = ['claude']; // backward-compat
-  }
-
-  const visto = new Set();
-  const targets = [];
-  for (const t of candidatos) {
-    if (visto.has(t)) continue;
-    visto.add(t);
-    if (!RUNTIMES[t]) {
-      log.warn && log.warn(`[expandir-targets] Target desconocido omitido: "${t}". Disponibles: ${Object.keys(RUNTIMES).join(', ')}`);
-      omitidos.push(t);
-      continue;
-    }
-    targets.push(t);
-  }
-
-  if (targets.length === 0) {
-    errores.push('Ningún target válido tras expansión.');
-  }
-
-  return { targets, omitidos, errores };
-}
-
-module.exports = { expandirTargets };
+'use strict';
+
+/**
+ * Expansión de --target (CSV) y --all-runtimes para multi-target install.
+ *
+ * ADR-0019 Sub-fase 2.5.
+ *
+ * Extraído de bin/swl-ses.js para permitir tests unitarios. NUNCA debe tener
+ * side effects fuera de logging — solo manipula la lista de strings.
+ *
+ * @module scripts/lib/expandir-targets
+ */
+
+const { listarRuntimesInstalables, RUNTIMES } = require('./detectar-runtime');
+
+/**
+ * Expande las opciones del CLI a un array de target IDs.
+ *
+ * Reglas:
+ *  - `all_runtimes` tiene prioridad sobre `target`. Si ambos vienen, se loggea
+ *    aviso (vía `logger.warn`) y se usa `all_runtimes`.
+ *  - `target='a,b,c'` → ['a','b','c'].
+ *  - `target='claude'` → ['claude'].
+ *  - Sin nada → ['claude'] (default histórico, backward-compat).
+ *  - Duplicados se deduplican preservando el primer orden.
+ *  - Targets desconocidos se omiten con aviso (logger.warn).
+ *
+ * @param {object} opciones - Objeto con `target` (string|undefined) y `all_runtimes` (bool).
+ * @param {object} [logger] - Sustituible para tests. Default console.
+ * @returns {{ targets: string[], omitidos: string[], errores: string[] }}
+ */
+function expandirTargets(opciones, logger) {
+  const log = logger || console;
+  const omitidos = [];
+  const errores = [];
+
+  let candidatos;
+  if (opciones.all_runtimes) {
+    if (opciones.target && typeof opciones.target === 'string') {
+      log.warn && log.warn('[expandir-targets] --all-runtimes tiene prioridad sobre --target; se ignora --target.');
+    }
+    candidatos = listarRuntimesInstalables();
+  } else if (typeof opciones.target === 'string' && opciones.target.includes(',')) {
+    candidatos = opciones.target.split(',').map(s => s.trim()).filter(Boolean);
+  } else if (typeof opciones.target === 'string' && opciones.target.length > 0) {
+    candidatos = [opciones.target.trim()];
+  } else {
+    candidatos = ['claude']; // backward-compat
+  }
+
+  const visto = new Set();
+  const targets = [];
+  for (const t of candidatos) {
+    if (visto.has(t)) continue;
+    visto.add(t);
+    if (!RUNTIMES[t]) {
+      log.warn && log.warn(`[expandir-targets] Target desconocido omitido: "${t}". Disponibles: ${Object.keys(RUNTIMES).join(', ')}`);
+      omitidos.push(t);
+      continue;
+    }
+    targets.push(t);
+  }
+
+  if (targets.length === 0) {
+    errores.push('Ningún target válido tras expansión.');
+  }
+
+  return { targets, omitidos, errores };
+}
+
+module.exports = { expandirTargets };

package/scripts/lib/hooks-settings.js

@@ -689,18 +689,55 @@ function registrarOptimizaciones(settingsPath) {
  * hooks con formato válido. No valida contenido semántico, solo estructura.
  *
  * @param {string} settingsPath
+ * @param {object} [opts]
+ * @param {'claude'|'plano'} [opts.formatoHooks='claude'] - 'claude' valida el
+ *   esquema de Claude Code ({matcher, hooks:[{type,command}]}, eventos
+ *   PascalCase). 'plano' valida hooks.json de Cursor/Codex: entradas planas
+ *   ({command, type?}) bajo eventos camelCase PROPIOS del runtime — los
+ *   nombres de evento NO se validan contra whitelist porque cada runtime
+ *   define su set y lo amplía por versión (afterFileEdit,
+ *   beforeShellExecution, etc. son legítimos en Cursor; el esquema Claude
+ *   los marcaba como error — caso real doctor 2026-07-03).
  * @returns {{ ok: boolean, problemas: string[] }}
  */
-function validarEstructuraSettings(settingsPath) {
+function validarEstructuraSettings(settingsPath, opts = {}) {
+  const formatoHooks = opts.formatoHooks || 'claude';
   const settings = leerSettings(settingsPath);
   const problemas = [];
 
-  // Validar sección hooks
-  if (settings.hooks) {
+  // Formato plano (Cursor/Codex hooks.json): shape-only, sin whitelist de eventos.
+  if (settings.hooks && formatoHooks === 'plano') {
+    if (typeof settings.hooks !== 'object' || Array.isArray(settings.hooks)) {
+      problemas.push('hooks: debe ser un objeto { evento: [entradas] }');
+    } else {
+      for (const [evento, entradas] of Object.entries(settings.hooks)) {
+        if (!Array.isArray(entradas)) {
+          problemas.push(`hooks.${evento}: debe ser un array de entradas`);
+          continue;
+        }
+        for (let i = 0; i < entradas.length; i++) {
+          const entrada = entradas[i];
+          if (!entrada || typeof entrada !== 'object') {
+            problemas.push(`hooks.${evento}[${i}]: debe ser un objeto`);
+            continue;
+          }
+          if (typeof entrada.command !== 'string' || !entrada.command) {
+            problemas.push(`hooks.${evento}[${i}]: falta campo command (string)`);
+          }
+        }
+      }
+    }
+  }
+
+  // Validar sección hooks (esquema Claude Code)
+  if (settings.hooks && formatoHooks === 'claude') {
     const eventosValidos = new Set([
       'PreToolUse', 'PostToolUse', 'UserPromptSubmit', 'Stop',
       'SubagentStart', 'SubagentStop', 'PreCompact', 'PostCompact',
       'Notification', 'SessionStart', 'TaskCompleted',
+      // Codex CLI usa la forma Claude en su hooks.json pero agrega este evento
+      // propio (ver transformadores/codex.js EVENTOS_VALIDOS).
+      'PermissionRequest',
     ]);
 
     for (const [evento, entradas] of Object.entries(settings.hooks)) {

package/scripts/lib/preservar-usuario.js

@@ -34,7 +34,7 @@ const path = require('path');
  *   - /swl:evolucionar → skills auto-generados en habilidades/
  *   - /swl:crear-skill → skills nuevos en habilidades/
  *   - session-store → .planning/sessions/*.json
- *   - context-compressor → .planning/COMPACTACION.md
+ *   - /swl:compactar → .planning/COMPACTACION.md
  *   - cron-store → .planning/cron/
  *   - gateway → .planning/gateway-sessions.json
  *   - agent-comms → .planning/comms/
@@ -181,6 +181,41 @@ function dirBackup(baseDir, version) {
   return path.join(baseDir, '.planning', 'backups', `v${version}`);
 }
 
+/**
+ * Subruta segura de un archivo DENTRO del directorio de backups.
+ *
+ * Un destino fuera de baseDir (install --global: ~/.claude, ~/.openclaude)
+ * produce un path.relative con segmentos '..' que ESCAPAN del directorio
+ * versionado: `.planning/backups/v2.3.1/../../.claude/...` colapsa a
+ * `.planning/.claude/...` (bug 2026-07-03: 1147 backups globales aterrizaron
+ * fuera del dir de backups y aparecieron como archivos nuevos en el repo).
+ * Se neutralizan '..', '.' y dos puntos de unidad preservando la estructura.
+ *
+ * @param {string} baseDir      - Raíz del proyecto.
+ * @param {string} rutaAbsoluta - Ruta absoluta del archivo a respaldar.
+ * @returns {string} Subruta relativa contenida (sin '..').
+ */
+function subrutaBackupSegura(baseDir, rutaAbsoluta) {
+  return path.relative(baseDir, rutaAbsoluta)
+    .split(/[\\/]/)
+    .filter(s => s && s !== '..' && s !== '.')
+    .map(s => s.replace(/:/g, ''))
+    .join(path.sep);
+}
+
+/**
+ * Ruta completa de backup para un archivo, garantizada dentro del
+ * directorio versionado de backups.
+ *
+ * @param {string} baseDir         - Raíz del proyecto.
+ * @param {string} versionAnterior - Versión que se está sobreescribiendo.
+ * @param {string} rutaAbsoluta    - Ruta absoluta del archivo a respaldar.
+ * @returns {string} Ruta absoluta del backup.
+ */
+function rutaBackupSegura(baseDir, versionAnterior, rutaAbsoluta) {
+  return path.join(dirBackup(baseDir, versionAnterior), subrutaBackupSegura(baseDir, rutaAbsoluta));
+}
+
 /**
  * Crea un backup de un archivo antes de sobreescribirlo.
  *
@@ -195,10 +230,8 @@ function crearBackup(baseDir, rutaAbsoluta, versionAnterior) {
   }
 
   try {
-    const rutaRelativa = path.relative(baseDir, rutaAbsoluta);
-    const backupDir    = dirBackup(baseDir, versionAnterior);
-    const rutaBackup   = path.join(backupDir, rutaRelativa);
-    const dirPadre     = path.dirname(rutaBackup);
+    const rutaBackup = rutaBackupSegura(baseDir, versionAnterior, rutaAbsoluta);
+    const dirPadre   = path.dirname(rutaBackup);
 
     if (!fs.existsSync(dirPadre)) {
       fs.mkdirSync(dirPadre, { recursive: true });
@@ -573,6 +606,7 @@ module.exports = {
 
   // Nivel 2: Backup
   crearBackup,
+  rutaBackupSegura,
   registrarBackup,
   listarBackups,
   restaurarBackup,