@saulwade/swl-ses 2.4.1 → 2.4.3

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/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);
 
@@ -322,21 +378,32 @@ function detectarInstalacionesDuales(runtimeId, opciones = {}) {
  *
  * @returns {string[]} Lista de runtime IDs ordenada de "más usado" a "menos usado".
  */
-function listarRuntimesInstalables() {
-  return [
+function listarRuntimesInstalables(opciones = {}) {
+  const existeDir = opciones.existeDir || fs.existsSync;
+  const base = [
     'claude',     // Soporte completo, primer ciudadano
     'cursor',     // Soporte parcial — reglas + MCP
     'codex',      // Soporte parcial — AGENTS.md + MCP (v1.5.0+)
     'opencode',   // Soporte completo
     'gemini',     // Soporte completo
     'copilot',    // Soporte parcial — agentes consolidados
-    // 'openclaude' intencionalmente excluido — comparte dir con claude
   ];
+  // OpenClaude comparte el dir de PROYECTO (.claude/) con Claude Code, así
+  // que NO se bootstrapea por default (evita duplicados para quien no lo
+  // usa). Pero su GLOBAL (~/.openclaude) es un dir propio: si YA existe (el
+  // usuario lo instaló alguna vez), --all-runtimes DEBE actualizarlo —
+  // excluirlo incondicionalmente dejaba un drift de versión permanente que
+  // ningún reinstall masivo cerraba (caso real doctor 2026-07-03: todo el
+  // parque en 2.4.2 y ~/.openclaude clavado en 2.4.1 pese a --all-runtimes).
+  if (existeDir(RUNTIMES.openclaude.global)) base.splice(1, 0, 'openclaude');
+  return base;
 }
 
 module.exports = {
   RUNTIMES,
   detectarRuntimes,
+  esDirGlobalDeAlgunRuntime,
+  scopesReales,
   detectarInstalacionesDuales,
   obtenerRuntime,
   calcularRutas,

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/tui/pantallas/inspect.js

@@ -1,173 +1,175 @@
-'use strict';
-
-/**
- * Pantalla Inspect — navegador read-only de componentes instalados.
- *
- * Flujo:
- *   1. Lista de instalaciones detectadas (runtime + scope + perfil + version)
- *   2. Al seleccionar una, muestra detalles:
- *      - Componentes por categoría (con conteos)
- *      - Última actualización
- *      - Lista de hooks registrados
- *      - Lista de skills disponibles
- *
- * No modifica nada. Solo lee de los archivos de estado.
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const { selectorUnico } = require('../componentes/selector-unico');
-const render = require('../lib/render');
-const teclas = require('../lib/teclas');
-const { colores, semantico, iconos } = require('../lib/colores');
-
-function _cargarDatosInstalaciones() {
-  let detectarRuntimes, cargarEstado;
-  try {
-    ({ detectarRuntimes } = require('../../lib/detectar-runtime'));
-    ({ cargarEstado } = require('../../lib/estado'));
-  } catch (_) {
-    return [];
-  }
-
-  const runtimes = detectarRuntimes();
-  const filas = [];
-  for (const runtime of runtimes) {
-    const candidatos = [
-      { ruta: runtime.global, scope: 'global' },
-      { ruta: path.resolve(runtime.local), scope: 'proyecto' },
-    ];
-    for (const { ruta, scope } of candidatos) {
-      if (!fs.existsSync(ruta)) continue;
-      const estado = cargarEstado(ruta);
-      if (!estado) continue;
-      filas.push({
-        id: `${runtime.id}:${scope}`,
-        runtimeId: runtime.id,
-        runtimeNombre: runtime.nombre,
-        scope,
-        ruta,
-        version: estado.versionSistema || 'desconocida',
-        perfil: estado.perfil || '-',
-        instalado: estado.fechaInstalacion || estado.timestamp || '-',
-        componentes: estado.componentesInstalados || [],
-        archivos: estado.archivosInstalados || [],
-      });
-    }
-  }
-  return filas;
-}
-
-function _agruparPorCategoria(archivos) {
-  const grupos = {};
-  for (const a of archivos) {
-    const cat = a.tipo || a.categoria || 'otros';
-    grupos[cat] = (grupos[cat] || 0) + 1;
-  }
-  return grupos;
-}
-
-function _pantallaDetalle(fila) {
-  return new Promise((resolve) => {
-    if (!render.ES_TTY || !process.stdin.isTTY) {
-      resolve();
-      return;
-    }
-
-    function _renderizar() {
-      render.limpiarPantalla();
-      const { cols, rows } = render.obtenerDimensiones();
-
-      render.escribirEn(2, 3, semantico.titulo(`${fila.runtimeNombre} — ${fila.scope}`));
-      render.escribirEn(3, 3, colores.dim(fila.ruta));
-
-      const datos = [
-        ['Versión', colores.cyan('v' + fila.version)],
-        ['Perfil', semantico.enfasis(fila.perfil)],
-        ['Instalado', fila.instalado],
-        ['Total componentes', String(fila.componentes.length)],
-        ['Total archivos', String(fila.archivos.length)],
-      ];
-
-      datos.forEach((d, i) => {
-        render.escribirEn(5 + i, 5,
-          render.rellenarDer(colores.dim(d[0] + ':'), 22) + d[1]);
-      });
-
-      // Conteos por categoría
-      const grupos = _agruparPorCategoria(fila.archivos);
-      const categorias = Object.entries(grupos).sort(([a], [b]) => a.localeCompare(b));
-
-      const filaCat = 5 + datos.length + 2;
-      render.escribirEn(filaCat, 3, semantico.enfasis('Archivos por categoría:'));
-      categorias.forEach(([cat, n], i) => {
-        const fila = filaCat + 1 + i;
-        if (fila >= rows - 3) return;
-        render.escribirEn(fila, 5,
-          render.rellenarDer(`${iconos.punto} ${cat}`, 22) +
-          colores.cyan(String(n).padStart(4)));
-      });
-
-      render.dibujarPiePagina([
-        ['Enter|Esc', 'volver al listado'],
-      ]);
-    }
-
-    render.iniciarModoTui();
-    _renderizar();
-
-    const onResize = () => _renderizar();
-    process.stdout.on('resize', onResize);
-
-    const teclado = teclas.crearTeclado();
-    function _finalizar() {
-      teclado.desactivar();
-      process.stdout.removeListener('resize', onResize);
-      render.salirModoTui();
-      resolve();
-    }
-    teclado.on('return', _finalizar);
-    teclado.on('escape', _finalizar);
-    teclado.activar();
-  });
-}
-
-async function ejecutarInspect() {
-  const instalaciones = _cargarDatosInstalaciones();
-
-  if (instalaciones.length === 0) {
-    return {
-      exito: false,
-      error: 'No se detectaron instalaciones SWL en este equipo.',
-      sugerencia: 'Ejecuta swl-ses install para crear una.',
-    };
-  }
-
-  // Loop: seleccionar una instalación → ver detalle → volver al listado.
-  // Esc en el listado sale del Inspect.
-  while (true) {
-    const items = instalaciones.map(i => ({
-      valor: i.id,
-      etiqueta: `${i.runtimeNombre} (${i.scope}) — v${i.version} · perfil ${i.perfil}`,
-      descripcion: `${i.componentes.length} componentes · ${i.archivos.length} archivos · ${i.ruta}`,
-    }));
-
-    const elegida = await selectorUnico({
-      titulo: 'Inspect — Elige una instalación para ver detalle:',
-      items,
-    });
-    if (!elegida) break;
-
-    const fila = instalaciones.find(i => i.id === elegida);
-    if (fila) await _pantallaDetalle(fila);
-  }
-
-  return { exito: true };
-}
-
-module.exports = {
-  ejecutarInspect,
-  _cargarDatosInstalaciones,
-  _agruparPorCategoria,
-};
+'use strict';
+
+/**
+ * Pantalla Inspect — navegador read-only de componentes instalados.
+ *
+ * Flujo:
+ *   1. Lista de instalaciones detectadas (runtime + scope + perfil + version)
+ *   2. Al seleccionar una, muestra detalles:
+ *      - Componentes por categoría (con conteos)
+ *      - Última actualización
+ *      - Lista de hooks registrados
+ *      - Lista de skills disponibles
+ *
+ * No modifica nada. Solo lee de los archivos de estado.
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { selectorUnico } = require('../componentes/selector-unico');
+const render = require('../lib/render');
+const teclas = require('../lib/teclas');
+const { colores, semantico, iconos } = require('../lib/colores');
+
+function _cargarDatosInstalaciones() {
+  let detectarRuntimes, cargarEstado;
+  try {
+    ({ detectarRuntimes, scopesReales } = require('../../lib/detectar-runtime'));
+    ({ cargarEstado } = require('../../lib/estado'));
+  } catch (_) {
+    return [];
+  }
+
+  const runtimes = detectarRuntimes();
+  const filas = [];
+  for (const runtime of runtimes) {
+    // Dedup + guard anti-fantasma: desde HOME, el local relativo resuelve al
+    // global propio (duplicado) o al de OTRO runtime (p.ej. .claude de
+    // OpenClaude = global de Claude Code) — ver scopesReales().
+    const candidatos = scopesReales(runtime).map(({ dir, esGlobal }) => (
+      { ruta: dir, scope: esGlobal ? 'global' : 'proyecto' }
+    ));
+    for (const { ruta, scope } of candidatos) {
+      if (!fs.existsSync(ruta)) continue;
+      const estado = cargarEstado(ruta);
+      if (!estado) continue;
+      filas.push({
+        id: `${runtime.id}:${scope}`,
+        runtimeId: runtime.id,
+        runtimeNombre: runtime.nombre,
+        scope,
+        ruta,
+        version: estado.versionSistema || 'desconocida',
+        perfil: estado.perfil || '-',
+        instalado: estado.fechaInstalacion || estado.timestamp || '-',
+        componentes: estado.componentesInstalados || [],
+        archivos: estado.archivosInstalados || [],
+      });
+    }
+  }
+  return filas;
+}
+
+function _agruparPorCategoria(archivos) {
+  const grupos = {};
+  for (const a of archivos) {
+    const cat = a.tipo || a.categoria || 'otros';
+    grupos[cat] = (grupos[cat] || 0) + 1;
+  }
+  return grupos;
+}
+
+function _pantallaDetalle(fila) {
+  return new Promise((resolve) => {
+    if (!render.ES_TTY || !process.stdin.isTTY) {
+      resolve();
+      return;
+    }
+
+    function _renderizar() {
+      render.limpiarPantalla();
+      const { cols, rows } = render.obtenerDimensiones();
+
+      render.escribirEn(2, 3, semantico.titulo(`${fila.runtimeNombre} — ${fila.scope}`));
+      render.escribirEn(3, 3, colores.dim(fila.ruta));
+
+      const datos = [
+        ['Versión', colores.cyan('v' + fila.version)],
+        ['Perfil', semantico.enfasis(fila.perfil)],
+        ['Instalado', fila.instalado],
+        ['Total componentes', String(fila.componentes.length)],
+        ['Total archivos', String(fila.archivos.length)],
+      ];
+
+      datos.forEach((d, i) => {
+        render.escribirEn(5 + i, 5,
+          render.rellenarDer(colores.dim(d[0] + ':'), 22) + d[1]);
+      });
+
+      // Conteos por categoría
+      const grupos = _agruparPorCategoria(fila.archivos);
+      const categorias = Object.entries(grupos).sort(([a], [b]) => a.localeCompare(b));
+
+      const filaCat = 5 + datos.length + 2;
+      render.escribirEn(filaCat, 3, semantico.enfasis('Archivos por categoría:'));
+      categorias.forEach(([cat, n], i) => {
+        const fila = filaCat + 1 + i;
+        if (fila >= rows - 3) return;
+        render.escribirEn(fila, 5,
+          render.rellenarDer(`${iconos.punto} ${cat}`, 22) +
+          colores.cyan(String(n).padStart(4)));
+      });
+
+      render.dibujarPiePagina([
+        ['Enter|Esc', 'volver al listado'],
+      ]);
+    }
+
+    render.iniciarModoTui();
+    _renderizar();
+
+    const onResize = () => _renderizar();
+    process.stdout.on('resize', onResize);
+
+    const teclado = teclas.crearTeclado();
+    function _finalizar() {
+      teclado.desactivar();
+      process.stdout.removeListener('resize', onResize);
+      render.salirModoTui();
+      resolve();
+    }
+    teclado.on('return', _finalizar);
+    teclado.on('escape', _finalizar);
+    teclado.activar();
+  });
+}
+
+async function ejecutarInspect() {
+  const instalaciones = _cargarDatosInstalaciones();
+
+  if (instalaciones.length === 0) {
+    return {
+      exito: false,
+      error: 'No se detectaron instalaciones SWL en este equipo.',
+      sugerencia: 'Ejecuta swl-ses install para crear una.',
+    };
+  }
+
+  // Loop: seleccionar una instalación → ver detalle → volver al listado.
+  // Esc en el listado sale del Inspect.
+  while (true) {
+    const items = instalaciones.map(i => ({
+      valor: i.id,
+      etiqueta: `${i.runtimeNombre} (${i.scope}) — v${i.version} · perfil ${i.perfil}`,
+      descripcion: `${i.componentes.length} componentes · ${i.archivos.length} archivos · ${i.ruta}`,
+    }));
+
+    const elegida = await selectorUnico({
+      titulo: 'Inspect — Elige una instalación para ver detalle:',
+      items,
+    });
+    if (!elegida) break;
+
+    const fila = instalaciones.find(i => i.id === elegida);
+    if (fila) await _pantallaDetalle(fila);
+  }
+
+  return { exito: true };
+}
+
+module.exports = {
+  ejecutarInspect,
+  _cargarDatosInstalaciones,
+  _agruparPorCategoria,
+};