@saulwade/swl-ses 2.5.3 → 2.6.1

package/scripts/lib/hooks-settings.js

@@ -58,6 +58,17 @@ function escribirSettings(settingsPath, settings) {
  * Determina si un hook entry en settings.json pertenece a SWL.
  * @param {object} entry - { matcher, hooks: [{ type, command }] }
  * @returns {boolean}
+ *
+ * ACOPLAMIENTO (re-auditoría nemesis iter-3): esta función y
+ * `hooksSWLRegistrados` deben reconocer los MISMOS formatos de comando. Hoy
+ * ambas son ciegas al modo wrapper (`bash ./hooks/_run-hook.sh <name>.js`,
+ * opt-in SWL_HOOKS_USAR_WRAPPER=1, default en v6.0.0) — esa ceguera se
+ * COMPENSA (registrarHooks preserva los wrapper como noSWL, hooksSWLRegistrados
+ * no los reune → ni pérdida ni duplicación). Al hacer una wrapper-aware para
+ * v6.0.0, actualizar la OTRA en el MISMO commit: si solo esHookSWL reconoce el
+ * wrapper, registrarHooks los quitaría de noSWL sin que hooksSWLRegistrados los
+ * reuna → se desregistran (regresión). El test wrapper-mode de
+ * instalador-transaccional.test.js vigila este invariante.
  */
 function esHookSWL(entry) {
   const hooksArr = entry.hooks || [];
@@ -68,6 +79,39 @@ function esHookSWL(entry) {
   });
 }
 
+/**
+ * Devuelve los basenames de los hooks SWL actualmente registrados en
+ * settings.json (ej. ['extraccion-aprendizajes.js', ...]). Se usa para
+ * PRESERVAR los hooks pre-existentes al re-registrar: sin esto, derivar el
+ * set solo de lo recién copiado desregistraría los hooks que colisionaron
+ * sin --force pero siguen en disco y funcionando (regresión detectada por la
+ * re-auditoría nemesis iter-2).
+ *
+ * @param {string} settingsPath
+ * @returns {string[]} basenames únicos de hooks SWL registrados.
+ *
+ * ACOPLAMIENTO con `esHookSWL` (ver su docstring): ambas deben reconocer los
+ * mismos formatos de comando. El regex de abajo captura el modo inline
+ * (`node ... hooks/x.js`) y el wrapper ABSOLUTO (`bash "…/hooks/x.js"`), pero
+ * NO el wrapper RELATIVO (`bash ./hooks/_run-hook.sh x.js`, nombre pelón). Esa
+ * ceguera se compensa hoy con la de esHookSWL; al volver una wrapper-aware,
+ * actualizar la otra en el mismo commit.
+ */
+function hooksSWLRegistrados(settingsPath) {
+  const settings = leerSettings(settingsPath);
+  const nombres = new Set();
+  for (const grupos of Object.values(settings.hooks || {})) {
+    if (!Array.isArray(grupos)) continue;
+    for (const entry of grupos) {
+      for (const h of (entry.hooks || [])) {
+        const m = String(h.command || '').match(/hooks[\/\\]([\w.-]+\.js)/);
+        if (m) nombres.add(m[1]);
+      }
+    }
+  }
+  return [...nombres];
+}
+
 /**
  * Calcula la ruta del settings.json para un runtime.
  * @param {object} runtime - Configuración del runtime
@@ -815,6 +859,7 @@ module.exports = {
   verificarHooks,
   repararHooks,
   esHookSWL,
+  hooksSWLRegistrados,
   registrarOptimizaciones,
   verificarOptimizaciones,
   validarEstructuraSettings,

package/scripts/lib/limpiar-basura-global.js

@@ -0,0 +1,161 @@
+'use strict';
+
+/**
+ * limpiar-basura-global.js — Purga de directorios basura de una instalación
+ * global de swl-ses.
+ *
+ * Caso de origen (2026-07-15): un `install --global` crea `~/_userland`. Una
+ * versión previa de `swl-ses doctor` contaba ese `_userland` como marcador de
+ * "proyecto swl" (`esProyectoSwl`), así que correr `doctor` desde el HOME
+ * sembraba `~/.planning/` con marcadores scaffold (`# PROJECT\n\n(Generado por
+ * swl-ses doctor)`). Como el HOME no es un proyecto, ese `.planning/` es basura;
+ * peor, hooks que resolvían la raíz vía raiz-proyecto la capturaban y volcaban
+ * telemetría ahí. El fix de raiz-proyecto (frontera del HOME) corta la captura;
+ * este módulo purga el scaffold ya sembrado en el próximo install global.
+ *
+ * También purga un `~/_userland/` VACÍO: el contenedor de plugins userland que
+ * un install global dejaba en el HOME (subdirs agentes/habilidades/plugins/
+ * reglas con solo `.gitkeep`). El instalador actual no lo crea ahí, así que un
+ * `_userland` vacío en el HOME es scaffold huérfano.
+ *
+ * Conservador por diseño (invariantes de seguridad): SOLO elimina un `.planning/`
+ * cuyos marcadores llevan la huella del scaffold de doctor, y un `_userland/`
+ * SIN archivos reales. Un proyecto real o un `_userland` con plugins del usuario
+ * nunca se tocan.
+ *
+ * Zero-deps.
+ *
+ * @module scripts/lib/limpiar-basura-global
+ */
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+// Huella inequívoca del scaffold vacío que `swl-ses doctor` escribía en cada
+// marcador (`# PROJECT\n\n(Generado por swl-ses doctor)\n`).
+const HUELLA_SCAFFOLD_DOCTOR = '(Generado por swl-ses doctor)';
+const MARCADORES = ['PROYECTO.md', 'REQUISITOS.md', 'HOJA-RUTA.md', 'ESTADO.md'];
+
+// Archivos que NO cuentan como contenido real (placeholders de scaffold).
+const ARCHIVOS_PLACEHOLDER = new Set(['.gitkeep', '.DS_Store', 'Thumbs.db']);
+
+/**
+ * ¿El `.planning/` de `dir` es el scaffold espurio de doctor (no un proyecto
+ * real)? Señal: existe al menos un marcador y TODOS los marcadores presentes
+ * llevan la huella del scaffold. Un proyecto real tiene marcadores con
+ * contenido propio → devuelve false y no se toca.
+ *
+ * @param {string} dir - Directorio que contiene el `.planning/` a evaluar.
+ * @returns {boolean}
+ */
+function esPlanningEspurio(dir) {
+  const planning = path.join(dir, '.planning');
+  let esDir = false;
+  try {
+    esDir = fs.statSync(planning).isDirectory();
+  } catch (_) {
+    return false; // no existe
+  }
+  if (!esDir) return false;
+
+  const presentes = MARCADORES.filter(m => fs.existsSync(path.join(planning, m)));
+  if (presentes.length === 0) return false;
+
+  return presentes.every(m => {
+    try {
+      return fs.readFileSync(path.join(planning, m), 'utf8').includes(HUELLA_SCAFFOLD_DOCTOR);
+    } catch (_) {
+      return false;
+    }
+  });
+}
+
+/**
+ * Cuenta archivos reales (no placeholders de scaffold) bajo `dir`, recursivo.
+ * @param {string} dir
+ * @returns {number}
+ */
+function contarArchivosReales(dir) {
+  let entradas;
+  try {
+    entradas = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (_) {
+    return 0;
+  }
+  let n = 0;
+  for (const e of entradas) {
+    if (e.isDirectory()) {
+      n += contarArchivosReales(path.join(dir, e.name));
+    } else if (!ARCHIVOS_PLACEHOLDER.has(e.name)) {
+      n += 1;
+    }
+  }
+  return n;
+}
+
+/**
+ * ¿El `_userland/` de `dir` es un scaffold vacío (sin plugins reales del
+ * usuario)? Señal: existe y no contiene ningún archivo real (solo placeholders
+ * como `.gitkeep`). Un `_userland` con plugins del usuario → false, no se toca.
+ *
+ * @param {string} dir
+ * @returns {boolean}
+ */
+function esUserlandVacio(dir) {
+  const userland = path.join(dir, '_userland');
+  let esDir = false;
+  try {
+    esDir = fs.statSync(userland).isDirectory();
+  } catch (_) {
+    return false; // no existe
+  }
+  if (!esDir) return false;
+  return contarArchivosReales(userland) === 0;
+}
+
+/**
+ * Elimina los directorios basura de una instalación global en el HOME:
+ *   - `.planning/` espurio sembrado por doctor (huella del scaffold).
+ *   - `_userland/` vacío (scaffold sin plugins del usuario).
+ * Idempotente: si no hay basura, no hace nada. Conservador: cada objetivo tiene
+ * su invariante de seguridad y NUNCA borra contenido real (proyecto o plugins).
+ * Un fallo de borrado en un objetivo no aborta los demás.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.home] - Raíz global a limpiar (default: os.homedir()).
+ * @param {boolean} [opts.dryRun=false] - No borra; solo reporta qué borraría.
+ * @returns {{eliminados: string[], dryRun: boolean}} Paths eliminados (o que se
+ *   eliminarían en dryRun).
+ */
+function limpiarBasuraGlobal(opts = {}) {
+  const home = opts.home || os.homedir();
+  const dryRun = !!opts.dryRun;
+  const eliminados = [];
+
+  const objetivos = [
+    { detectar: () => esPlanningEspurio(home), ruta: path.join(home, '.planning') },
+    { detectar: () => esUserlandVacio(home), ruta: path.join(home, '_userland') },
+  ];
+
+  for (const obj of objetivos) {
+    if (!obj.detectar()) continue;
+    if (!dryRun) {
+      try {
+        fs.rmSync(obj.ruta, { recursive: true, force: true });
+      } catch (_) {
+        continue; // no se pudo borrar: no reportar como eliminado, seguir con el resto
+      }
+    }
+    eliminados.push(obj.ruta);
+  }
+
+  return { eliminados, dryRun };
+}
+
+module.exports = {
+  limpiarBasuraGlobal,
+  esPlanningEspurio,
+  esUserlandVacio,
+  HUELLA_SCAFFOLD_DOCTOR,
+};

package/scripts/lib/toml-merge.js

@@ -1,204 +1,204 @@
-'use strict';
-
-/**
- * Merge mínimo de secciones TOML — zero-deps.
- *
- * Opera sobre el formato concreto de `~/.codex/config.toml` (OpenAI Codex CLI):
- *   [mcp_servers.<name>]
- *   command = "node"
- *   args = ["...", "..."]
- *   [mcp_servers.<name>.env]
- *   KEY = "value"
- *
- * Reglas:
- *  - NUNCA reescribe el archivo entero. Solo agrega o reemplaza la sección
- *    `[mcp_servers.<name>]` indicada (incluyendo sub-tabla `.env`).
- *  - Si el archivo no existe lo crea con permisos 0600.
- *  - Si el archivo tiene comentarios o secciones desconocidas, las preserva.
- *  - Bloque "owned" delimitado por marcadores `# SWL-MCP-BEGIN <name>` /
- *    `# SWL-MCP-END <name>` para permitir actualizaciones idempotentes.
- *
- * NO soporta:
- *  - TOML completo (arrays multilínea complejos, inline tables, etc.)
- *  - Multi-section nested tables fuera de `mcp_servers.*`
- *
- * Si en el futuro Codex publica un comando idempotente `codex mcp add --idempotent`
- * podemos delegarle el trabajo y deprecar este helper.
- *
- * @module scripts/lib/toml-merge
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const { atomicWriteSync } = require('../../hooks/lib/atomic-write');
-
-const BEGIN_PREFIX = '# SWL-MCP-BEGIN';
-const END_PREFIX = '# SWL-MCP-END';
-
-/**
- * Serializa un servidor MCP en bloque TOML.
- *
- * @param {string} name - Nombre del server (identificador en config.toml).
- * @param {{ command: string, args?: string[], env?: Record<string,string> }} cfg
- * @returns {string} Bloque TOML con marcadores.
- */
-function serializarServidor(name, cfg) {
-  if (!name || typeof name !== 'string' || !/^[a-zA-Z0-9_-]+$/.test(name)) {
-    throw new Error(`Nombre de MCP server inválido: "${name}". Solo [a-zA-Z0-9_-].`);
-  }
-  if (!cfg || typeof cfg.command !== 'string' || cfg.command.length === 0) {
-    throw new Error(`MCP server "${name}" requiere "command" string no vacío.`);
-  }
-
-  const lineas = [];
-  lineas.push(`${BEGIN_PREFIX} ${name}`);
-  lineas.push(`[mcp_servers.${name}]`);
-  lineas.push(`command = ${tomlString(cfg.command)}`);
-
-  if (Array.isArray(cfg.args) && cfg.args.length > 0) {
-    const items = cfg.args.map(tomlString).join(', ');
-    lineas.push(`args = [${items}]`);
-  }
-
-  if (cfg.env && typeof cfg.env === 'object' && Object.keys(cfg.env).length > 0) {
-    lineas.push('');
-    lineas.push(`[mcp_servers.${name}.env]`);
-    for (const [k, v] of Object.entries(cfg.env)) {
-      if (typeof v !== 'string') {
-        throw new Error(`MCP server "${name}" env.${k} debe ser string (recibido: ${typeof v}).`);
-      }
-      // Solo claves alfanuméricas/_ en env names — TOML restricción razonable
-      if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(k)) {
-        throw new Error(`MCP server "${name}" env key inválido: "${k}".`);
-      }
-      lineas.push(`${k} = ${tomlString(v)}`);
-    }
-  }
-
-  lineas.push(`${END_PREFIX} ${name}`);
-  return lineas.join('\n');
-}
-
-/**
- * Escapa un string para TOML usando comillas dobles.
- * No usa basic-string raw para evitar pitfalls con backslashes.
- */
-function tomlString(s) {
-  // TOML basic string: escape backslash, doblequote, control chars.
-  const escapado = String(s)
-    .replace(/\\/g, '\\\\')
-    .replace(/"/g, '\\"')
-    .replace(/\n/g, '\\n')
-    .replace(/\r/g, '\\r')
-    .replace(/\t/g, '\\t');
-  return `"${escapado}"`;
-}
-
-/**
- * Inserta o actualiza un servidor MCP en `config.toml`.
- *
- * Idempotente: si el bloque ya existe con el mismo contenido, no escribe.
- * Si existe con contenido distinto, lo reemplaza dentro de los marcadores.
- * Si no existe, lo agrega al final del archivo precedido de línea en blanco.
- *
- * @param {string} rutaConfig - Path absoluto a config.toml (típicamente ~/.codex/config.toml).
- * @param {string} name - Nombre del MCP server (clave de [mcp_servers.<name>]).
- * @param {{ command: string, args?: string[], env?: Record<string,string> }} cfg
- * @returns {{ accion: 'creado' | 'agregado' | 'actualizado' | 'sin-cambios', ruta: string }}
- */
-function upsertMcpServer(rutaConfig, name, cfg) {
-  const bloqueNuevo = serializarServidor(name, cfg);
-
-  let existente = '';
-  let existia = false;
-  try {
-    existente = fs.readFileSync(rutaConfig, 'utf-8');
-    existia = true;
-  } catch (err) {
-    if (err.code !== 'ENOENT') throw err;
-    // Archivo no existe — se crea
-  }
-
-  const beginTag = `${BEGIN_PREFIX} ${name}`;
-  const endTag = `${END_PREFIX} ${name}`;
-
-  if (!existia) {
-    const dir = path.dirname(rutaConfig);
-    fs.mkdirSync(dir, { recursive: true });
-    const contenido = `# config.toml de Codex CLI — gestionado parcialmente por swl-ses\n# Bloques delimitados por SWL-MCP-BEGIN/END son regenerables.\n\n${bloqueNuevo}\n`;
-    atomicWriteSync(rutaConfig, contenido, 'utf8', { mode: 0o600 });
-    return { accion: 'creado', ruta: rutaConfig };
-  }
-
-  const idxBegin = existente.indexOf(beginTag);
-  const idxEnd = existente.indexOf(endTag);
-
-  // Caso 1: no existe el bloque → append al final
-  if (idxBegin === -1 || idxEnd === -1) {
-    const separador = existente.endsWith('\n') ? '\n' : '\n\n';
-    const contenido = existente + separador + bloqueNuevo + '\n';
-    atomicWriteSync(rutaConfig, contenido, 'utf8', { mode: 0o600 });
-    return { accion: 'agregado', ruta: rutaConfig };
-  }
-
-  // Caso 2: existe — comparar contenido
-  // Calculamos fin REAL incluyendo el endTag completo.
-  const finBloqueExistente = idxEnd + endTag.length;
-  const bloqueExistente = existente.slice(idxBegin, finBloqueExistente);
-
-  if (bloqueExistente === bloqueNuevo) {
-    return { accion: 'sin-cambios', ruta: rutaConfig };
-  }
-
-  const contenido = existente.slice(0, idxBegin) + bloqueNuevo + existente.slice(finBloqueExistente);
-  atomicWriteSync(rutaConfig, contenido, 'utf8', { mode: 0o600 });
-  return { accion: 'actualizado', ruta: rutaConfig };
-}
-
-/**
- * Elimina un bloque MCP server por nombre. Idempotente: si no existe, no hace nada.
- *
- * @param {string} rutaConfig
- * @param {string} name
- * @returns {{ accion: 'eliminado' | 'sin-cambios', ruta: string }}
- */
-function removeMcpServer(rutaConfig, name) {
-  let existente = '';
-  try {
-    existente = fs.readFileSync(rutaConfig, 'utf-8');
-  } catch (err) {
-    if (err.code === 'ENOENT') return { accion: 'sin-cambios', ruta: rutaConfig };
-    throw err;
-  }
-
-  const beginTag = `${BEGIN_PREFIX} ${name}`;
-  const endTag = `${END_PREFIX} ${name}`;
-  const idxBegin = existente.indexOf(beginTag);
-  const idxEnd = existente.indexOf(endTag);
-
-  if (idxBegin === -1 || idxEnd === -1) {
-    return { accion: 'sin-cambios', ruta: rutaConfig };
-  }
-
-  // Quitar bloque + posible newline previo y posterior (cosmético)
-  let inicio = idxBegin;
-  let fin = idxEnd + endTag.length;
-  // Comer un \n previo si existe (no comer doble \n para preservar separadores entre secciones)
-  if (inicio > 0 && existente[inicio - 1] === '\n') inicio--;
-  if (fin < existente.length && existente[fin] === '\n') fin++;
-
-  const contenido = existente.slice(0, inicio) + existente.slice(fin);
-  atomicWriteSync(rutaConfig, contenido, 'utf8', { mode: 0o600 });
-  return { accion: 'eliminado', ruta: rutaConfig };
-}
-
-module.exports = {
-  upsertMcpServer,
-  removeMcpServer,
-  serializarServidor,
-  // Para tests
-  _tomlString: tomlString,
-  BEGIN_PREFIX,
-  END_PREFIX,
-};
+'use strict';
+
+/**
+ * Merge mínimo de secciones TOML — zero-deps.
+ *
+ * Opera sobre el formato concreto de `~/.codex/config.toml` (OpenAI Codex CLI):
+ *   [mcp_servers.<name>]
+ *   command = "node"
+ *   args = ["...", "..."]
+ *   [mcp_servers.<name>.env]
+ *   KEY = "value"
+ *
+ * Reglas:
+ *  - NUNCA reescribe el archivo entero. Solo agrega o reemplaza la sección
+ *    `[mcp_servers.<name>]` indicada (incluyendo sub-tabla `.env`).
+ *  - Si el archivo no existe lo crea con permisos 0600.
+ *  - Si el archivo tiene comentarios o secciones desconocidas, las preserva.
+ *  - Bloque "owned" delimitado por marcadores `# SWL-MCP-BEGIN <name>` /
+ *    `# SWL-MCP-END <name>` para permitir actualizaciones idempotentes.
+ *
+ * NO soporta:
+ *  - TOML completo (arrays multilínea complejos, inline tables, etc.)
+ *  - Multi-section nested tables fuera de `mcp_servers.*`
+ *
+ * Si en el futuro Codex publica un comando idempotente `codex mcp add --idempotent`
+ * podemos delegarle el trabajo y deprecar este helper.
+ *
+ * @module scripts/lib/toml-merge
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { atomicWriteSync } = require('../../hooks/lib/atomic-write');
+
+const BEGIN_PREFIX = '# SWL-MCP-BEGIN';
+const END_PREFIX = '# SWL-MCP-END';
+
+/**
+ * Serializa un servidor MCP en bloque TOML.
+ *
+ * @param {string} name - Nombre del server (identificador en config.toml).
+ * @param {{ command: string, args?: string[], env?: Record<string,string> }} cfg
+ * @returns {string} Bloque TOML con marcadores.
+ */
+function serializarServidor(name, cfg) {
+  if (!name || typeof name !== 'string' || !/^[a-zA-Z0-9_-]+$/.test(name)) {
+    throw new Error(`Nombre de MCP server inválido: "${name}". Solo [a-zA-Z0-9_-].`);
+  }
+  if (!cfg || typeof cfg.command !== 'string' || cfg.command.length === 0) {
+    throw new Error(`MCP server "${name}" requiere "command" string no vacío.`);
+  }
+
+  const lineas = [];
+  lineas.push(`${BEGIN_PREFIX} ${name}`);
+  lineas.push(`[mcp_servers.${name}]`);
+  lineas.push(`command = ${tomlString(cfg.command)}`);
+
+  if (Array.isArray(cfg.args) && cfg.args.length > 0) {
+    const items = cfg.args.map(tomlString).join(', ');
+    lineas.push(`args = [${items}]`);
+  }
+
+  if (cfg.env && typeof cfg.env === 'object' && Object.keys(cfg.env).length > 0) {
+    lineas.push('');
+    lineas.push(`[mcp_servers.${name}.env]`);
+    for (const [k, v] of Object.entries(cfg.env)) {
+      if (typeof v !== 'string') {
+        throw new Error(`MCP server "${name}" env.${k} debe ser string (recibido: ${typeof v}).`);
+      }
+      // Solo claves alfanuméricas/_ en env names — TOML restricción razonable
+      if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(k)) {
+        throw new Error(`MCP server "${name}" env key inválido: "${k}".`);
+      }
+      lineas.push(`${k} = ${tomlString(v)}`);
+    }
+  }
+
+  lineas.push(`${END_PREFIX} ${name}`);
+  return lineas.join('\n');
+}
+
+/**
+ * Escapa un string para TOML usando comillas dobles.
+ * No usa basic-string raw para evitar pitfalls con backslashes.
+ */
+function tomlString(s) {
+  // TOML basic string: escape backslash, doblequote, control chars.
+  const escapado = String(s)
+    .replace(/\\/g, '\\\\')
+    .replace(/"/g, '\\"')
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\t/g, '\\t');
+  return `"${escapado}"`;
+}
+
+/**
+ * Inserta o actualiza un servidor MCP en `config.toml`.
+ *
+ * Idempotente: si el bloque ya existe con el mismo contenido, no escribe.
+ * Si existe con contenido distinto, lo reemplaza dentro de los marcadores.
+ * Si no existe, lo agrega al final del archivo precedido de línea en blanco.
+ *
+ * @param {string} rutaConfig - Path absoluto a config.toml (típicamente ~/.codex/config.toml).
+ * @param {string} name - Nombre del MCP server (clave de [mcp_servers.<name>]).
+ * @param {{ command: string, args?: string[], env?: Record<string,string> }} cfg
+ * @returns {{ accion: 'creado' | 'agregado' | 'actualizado' | 'sin-cambios', ruta: string }}
+ */
+function upsertMcpServer(rutaConfig, name, cfg) {
+  const bloqueNuevo = serializarServidor(name, cfg);
+
+  let existente = '';
+  let existia = false;
+  try {
+    existente = fs.readFileSync(rutaConfig, 'utf-8');
+    existia = true;
+  } catch (err) {
+    if (err.code !== 'ENOENT') throw err;
+    // Archivo no existe — se crea
+  }
+
+  const beginTag = `${BEGIN_PREFIX} ${name}`;
+  const endTag = `${END_PREFIX} ${name}`;
+
+  if (!existia) {
+    const dir = path.dirname(rutaConfig);
+    fs.mkdirSync(dir, { recursive: true });
+    const contenido = `# config.toml de Codex CLI — gestionado parcialmente por swl-ses\n# Bloques delimitados por SWL-MCP-BEGIN/END son regenerables.\n\n${bloqueNuevo}\n`;
+    atomicWriteSync(rutaConfig, contenido, 'utf8', { mode: 0o600 });
+    return { accion: 'creado', ruta: rutaConfig };
+  }
+
+  const idxBegin = existente.indexOf(beginTag);
+  const idxEnd = existente.indexOf(endTag);
+
+  // Caso 1: no existe el bloque → append al final
+  if (idxBegin === -1 || idxEnd === -1) {
+    const separador = existente.endsWith('\n') ? '\n' : '\n\n';
+    const contenido = existente + separador + bloqueNuevo + '\n';
+    atomicWriteSync(rutaConfig, contenido, 'utf8', { mode: 0o600 });
+    return { accion: 'agregado', ruta: rutaConfig };
+  }
+
+  // Caso 2: existe — comparar contenido
+  // Calculamos fin REAL incluyendo el endTag completo.
+  const finBloqueExistente = idxEnd + endTag.length;
+  const bloqueExistente = existente.slice(idxBegin, finBloqueExistente);
+
+  if (bloqueExistente === bloqueNuevo) {
+    return { accion: 'sin-cambios', ruta: rutaConfig };
+  }
+
+  const contenido = existente.slice(0, idxBegin) + bloqueNuevo + existente.slice(finBloqueExistente);
+  atomicWriteSync(rutaConfig, contenido, 'utf8', { mode: 0o600 });
+  return { accion: 'actualizado', ruta: rutaConfig };
+}
+
+/**
+ * Elimina un bloque MCP server por nombre. Idempotente: si no existe, no hace nada.
+ *
+ * @param {string} rutaConfig
+ * @param {string} name
+ * @returns {{ accion: 'eliminado' | 'sin-cambios', ruta: string }}
+ */
+function removeMcpServer(rutaConfig, name) {
+  let existente = '';
+  try {
+    existente = fs.readFileSync(rutaConfig, 'utf-8');
+  } catch (err) {
+    if (err.code === 'ENOENT') return { accion: 'sin-cambios', ruta: rutaConfig };
+    throw err;
+  }
+
+  const beginTag = `${BEGIN_PREFIX} ${name}`;
+  const endTag = `${END_PREFIX} ${name}`;
+  const idxBegin = existente.indexOf(beginTag);
+  const idxEnd = existente.indexOf(endTag);
+
+  if (idxBegin === -1 || idxEnd === -1) {
+    return { accion: 'sin-cambios', ruta: rutaConfig };
+  }
+
+  // Quitar bloque + posible newline previo y posterior (cosmético)
+  let inicio = idxBegin;
+  let fin = idxEnd + endTag.length;
+  // Comer un \n previo si existe (no comer doble \n para preservar separadores entre secciones)
+  if (inicio > 0 && existente[inicio - 1] === '\n') inicio--;
+  if (fin < existente.length && existente[fin] === '\n') fin++;
+
+  const contenido = existente.slice(0, inicio) + existente.slice(fin);
+  atomicWriteSync(rutaConfig, contenido, 'utf8', { mode: 0o600 });
+  return { accion: 'eliminado', ruta: rutaConfig };
+}
+
+module.exports = {
+  upsertMcpServer,
+  removeMcpServer,
+  serializarServidor,
+  // Para tests
+  _tomlString: tomlString,
+  BEGIN_PREFIX,
+  END_PREFIX,
+};