@saulwade/swl-ses 2.5.3 → 2.6.1

package/hooks/lib/singleton-guard.js

@@ -25,12 +25,14 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path = require('path');
 
-const DIR_LOCKS = path.join(process.cwd(), '.planning', 'locks');
+const DIR_LOCKS = path.join(raizProyecto(process.cwd()), '.planning', 'locks');
 const STALE_MS_DEFAULT = 5 * 60 * 1000; // 5 minutos
 const locksAdquiridos = new Set();
 let handlersRegistrados = false;
+let seqTmp = 0; // secuencia para nombres de temp únicos por proceso
 
 function rutaLock(nombre) {
   return path.join(DIR_LOCKS, `${nombre}.lock`);
@@ -59,8 +61,64 @@ function pidVivo(pid) {
 }
 
 /**
- * Intenta adquirir el lock. Retorna true si se adquirió, false si otro
- * proceso lo tiene activo.
+ * Escribe el lockfile con exclusión atómica y SIN ventana de archivo vacío:
+ * escribe el contenido completo en un temp único y lo ENLAZA (link(2)) a `ruta`.
+ * link es atómico y falla con EEXIST si `ruta` ya existe — misma garantía de
+ * exclusión mutua que O_EXCL — pero, a diferencia de open('wx')+write, `ruta`
+ * NUNCA aparece vacío: el inodo enlazado ya trae el JSON completo.
+ *
+ * Por qué NO open('wx')+write (hallazgo 2026-07-15): esa forma crea el archivo
+ * vacío y ESCRIBE después. Un contendiente en el path de takeover que lo leyera
+ * en esa ventana obtenía '' → JSON.parse lanza → leerLock=null →
+ * contenidoTomable(null)=true → hacía takeover de un lock YA ganado → DOS
+ * holders. Reproducido a ~10% con 16 procesos simultáneos sobre el path stale;
+ * antes no se veía porque el test no forzaba simultaneidad real.
+ * (Precedente: fs.existsSync+writeFileSync tampoco sirve — nemesis iter-2.)
+ *
+ * @param {string} ruta
+ * @param {string} nombre
+ * @returns {boolean} true si este proceso creó el lock.
+ */
+function crearLockExclusivo(ruta, nombre) {
+  const tmp = `${ruta}.${process.pid}.${++seqTmp}.tmp`;
+  try {
+    fs.writeFileSync(tmp, JSON.stringify({ pid: process.pid, ts: new Date().toISOString(), nombre }));
+    fs.linkSync(tmp, ruta); // atómico; lanza EEXIST si `ruta` ya existe
+    return true;
+  } catch (err) {
+    return false; // EEXIST (otro ganó) u otro error de I/O → no se adquirió
+  } finally {
+    try { fs.unlinkSync(tmp); } catch (_) { /* temp ya removido o nunca creado */ }
+  }
+}
+
+/**
+ * ¿Un CONTENIDO de lock ya leído es tomable? (proceso muerto, edad > staleMs,
+ * o contenido corrupto/nulo). Trabaja sobre el objeto, no re-lee el archivo —
+ * clave para el takeover: la decisión de remover se toma sobre el MISMO
+ * contenido que se acaba de leer bajo el guard, sin un segundo read que
+ * reintroduzca TOCTOU.
+ * @returns {boolean}
+ */
+function contenidoTomable(contenido, staleMs) {
+  if (!contenido || typeof contenido.pid === 'undefined') return true; // corrupto/nulo → tomable
+  const edad = Date.now() - Date.parse(contenido.ts);
+  const vivo = pidVivo(contenido.pid);
+  return !(vivo && edad < staleMs);
+}
+
+/**
+ * ¿El lock existente (en disco) es tomable? Lee el archivo y delega en
+ * contenidoTomable.
+ * @returns {boolean}
+ */
+function lockTomable(ruta, staleMs) {
+  return contenidoTomable(leerLock(ruta), staleMs);
+}
+
+/**
+ * Intenta adquirir el lock con exclusión ATÓMICA (O_EXCL). Retorna true si se
+ * adquirió, false si otro proceso lo tiene activo.
  *
  * @param {string} nombre - Identificador del lock (ej: 'auto-evolucion').
  * @param {object} [opts]
@@ -72,38 +130,113 @@ function adquirir(nombre, opts = {}) {
   ensureDir();
   const ruta = rutaLock(nombre);
 
-  // Verificar lock existente
-  if (fs.existsSync(ruta)) {
-    try {
-      const contenido = JSON.parse(fs.readFileSync(ruta, 'utf8'));
-      const edad = Date.now() - Date.parse(contenido.ts);
-      const vivo = pidVivo(contenido.pid);
+  // Caso primario: crear el lock de forma atómica. Dos procesos frescos
+  // simultáneos sobre un lock inexistente → solo UNO gana el O_EXCL.
+  if (crearLockExclusivo(ruta, nombre)) {
+    locksAdquiridos.add(nombre);
+    registrarHandlersCleanup();
+    return true;
+  }
 
-      if (vivo && edad < staleMs) {
-        // Lock activo y proceso vivo → no adquirir
-        return false;
-      }
-      // Lock stale o proceso muerto → tomar posesión
-    } catch {
-      // Lock corrupto → sobrescribir
+  // El lock existe. Si parece tomable (muerto/stale/corrupto), removerlo de
+  // forma SERIALIZADA (ver takeoverStaleSerializado) y reintentar el O_EXCL.
+  if (lockTomable(ruta, staleMs)) {
+    takeoverStaleSerializado(ruta, staleMs);
+    if (crearLockExclusivo(ruta, nombre)) {
+      locksAdquiridos.add(nombre);
+      registrarHandlersCleanup();
+      return true;
     }
   }
 
-  // Escribir lock con PID actual
+  return false;
+}
+
+/** Lee el contenido {pid, ts} del lock, o null si no existe/corrupto. */
+function leerLock(ruta) {
   try {
-    fs.writeFileSync(ruta, JSON.stringify({
-      pid: process.pid,
-      ts: new Date().toISOString(),
-      nombre,
-    }), 'utf8');
-    locksAdquiridos.add(nombre);
-    registrarHandlersCleanup();
-    return true;
+    return JSON.parse(fs.readFileSync(ruta, 'utf8'));
   } catch {
-    return false;
+    return null;
   }
 }
 
+// Un token de takeover se considera leaked (dueño muerto a mitad) si supera
+// esto: la sección crítica del takeover es de µs, así que segundos = fuga.
+const TAKEOVER_TOKEN_STALE_MS = 5000;
+
+/**
+ * Remueve un lock stale de forma SERIALIZADA y sin ventana de create fresco.
+ *
+ * La clase de bug que dos rondas de re-auditoría destaparon: cualquier diseño
+ * que "saque" el stale del path (unlink ciego, rename-out) abre una ventana en
+ * la que `ruta` queda libre y un proceso fresco puede colarse con O_EXCL, y
+ * luego el remover restaura/recrea encima → DOS holders. El fix de CLASE:
+ *
+ * 1. Serializar el takeover con un token O_EXCL (`<ruta>.takeover`): solo UN
+ *    taker entra a la sección crítica; los demás salen (otro lo maneja).
+ * 2. Dentro del token, re-leer `ruta` y `unlinkSync` SOLO si sigue tomable
+ *    (muerto/stale/corrupto). `ruta` está PRESENTE hasta ese unlink → ningún
+ *    create fresco puede colarse antes (falla EEXIST). Si el contenido pasó a
+ *    ser un lock VIVO distinto (otro tomó posesión legítima), NO se toca.
+ *
+ * Tras esto, el `crearLockExclusivo` del caller compite limpio por O_EXCL: si
+ * un proceso fresco ganó la ventana unlink→create, el caller falla EEXIST en
+ * vez de clobberear. Nunca dos holders.
+ *
+ * El token puede quedar leaked si el taker muere a mitad; se reclama por edad
+ * (>TAKEOVER_TOKEN_STALE_MS), acotando el bloqueo a segundos.
+ *
+ * @param {string} ruta
+ * @param {number} staleMs
+ */
+function takeoverStaleSerializado(ruta, staleMs) {
+  const token = `${ruta}.takeover`;
+  if (!adquirirTokenTakeover(token)) return; // otro taker está removiendo el stale
+  try {
+    const actual = leerLock(ruta);
+    if (contenidoTomable(actual, staleMs)) {
+      try { fs.unlinkSync(ruta); } catch { /* ya removido */ }
+    }
+    // else: `ruta` pasó a ser un lock VIVO legítimo — no tocar.
+  } finally {
+    try { fs.unlinkSync(token); } catch { /* nada */ }
+  }
+}
+
+/**
+ * Adquiere el token de takeover (O_EXCL). Si existe pero está leaked, lo reclama
+ * una vez. Un token queda leaked SOLO si el taker murió dentro de su sección
+ * crítica (leer+unlink, del orden de µs). Dos señales de leak, en orden:
+ *   1. pid del token MUERTO → el taker crasheó → reclamo INSTANTÁNEO (sin
+ *      esperar TAKEOVER_TOKEN_STALE_MS). Es el caso realista (SIGKILL/crash) y
+ *      con esto la ventana de bloqueo del leak baja de segundos a ~0.
+ *   2. pid vivo pero token viejo (>TAKEOVER_TOKEN_STALE_MS) → taker atascado
+ *      (patológico para una sección de µs) → reclamo por edad.
+ * El reclamo final es un crearLockExclusivo (O_EXCL): si dos takers reclaman a
+ * la vez, solo uno crea el token. Límite inherente (documentado): con locks de
+ * archivo zero-dep no hay exclusión mutua PERFECTA para el reclamo de stale
+ * —igual que proper-lockfile—; el riesgo residual es una carrera compuesta
+ * (leak en µs + doble-reclamo simultáneo) de probabilidad despreciable.
+ * @returns {boolean}
+ */
+function adquirirTokenTakeover(token) {
+  if (crearLockExclusivo(token, 'takeover')) return true;
+  const contenido = leerLock(token);
+  const pidMuerto = contenido && typeof contenido.pid !== 'undefined' && !pidVivo(contenido.pid);
+  let viejo = false;
+  try {
+    viejo = (Date.now() - fs.statSync(token).mtimeMs) > TAKEOVER_TOKEN_STALE_MS;
+  } catch {
+    return crearLockExclusivo(token, 'takeover'); // desapareció entre create y stat → reintentar
+  }
+  if (pidMuerto || viejo) {
+    try { fs.unlinkSync(token); } catch { /* otro lo removió */ }
+    return crearLockExclusivo(token, 'takeover');
+  }
+  return false;
+}
+
 /**
  * Libera el lock. Idempotente.
  *
@@ -123,6 +256,67 @@ function liberar(nombre) {
   locksAdquiridos.delete(nombre);
 }
 
+/**
+ * Sleep SÍNCRONO sin quemar CPU (Atomics.wait sobre un buffer efímero).
+ * Los hooks son procesos cortos de un solo propósito — bloquear el event
+ * loop unos ms para serializar un RMW es aceptable y evita el busy-loop.
+ * @param {number} ms
+ */
+function dormirSync(ms) {
+  try {
+    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+  } catch {
+    // SharedArrayBuffer no disponible: degradar a busy-wait acotado.
+    const fin = Date.now() + ms;
+    while (Date.now() < fin) { /* espera */ }
+  }
+}
+
+/**
+ * Ejecuta `fn` dentro de una sección crítica serializada por lock, con
+ * reintentos de adquisición (poll). Para RMW de archivos compartidos que NO
+ * deben perder datos por race (APRENDIZAJES.md) o cuyo incremento puede
+ * omitirse bajo contención (dirty.json).
+ *
+ * @param {string} nombre - Identificador del lock.
+ * @param {Function} fn - Trabajo a ejecutar dentro de la sección crítica.
+ * @param {object} [opts]
+ * @param {number} [opts.maxWaitMs=1000] - Tope total de espera para adquirir.
+ * @param {number} [opts.pollMs=25] - Intervalo entre intentos.
+ * @param {number} [opts.staleMs] - Se pasa a adquirir().
+ * @param {'ejecutar'|'omitir'} [opts.siNoAdquiere='ejecutar'] - Qué hacer si
+ *   no se adquiere el lock dentro de maxWaitMs: `ejecutar` corre fn igual
+ *   (best-effort, no pierde datos — la ventana de race ya se redujo al mínimo);
+ *   `omitir` salta fn (el trabajo es descartable, ej. un contador).
+ * @returns {{ejecutado:boolean, conLock:boolean}}
+ */
+function conLockRetry(nombre, fn, opts = {}) {
+  const maxWaitMs = opts.maxWaitMs != null ? opts.maxWaitMs : 1000;
+  const pollMs = opts.pollMs != null ? opts.pollMs : 25;
+  const siNoAdquiere = opts.siNoAdquiere || 'ejecutar';
+  const deadline = Date.now() + maxWaitMs;
+
+  let adquirido = adquirir(nombre, { staleMs: opts.staleMs });
+  while (!adquirido && Date.now() < deadline) {
+    dormirSync(pollMs);
+    adquirido = adquirir(nombre, { staleMs: opts.staleMs });
+  }
+
+  if (!adquirido) {
+    if (siNoAdquiere === 'omitir') return { ejecutado: false, conLock: false };
+    // best-effort: correr sin lock (mejor que perder el dato)
+    try { fn(); } finally { /* sin lock que liberar */ }
+    return { ejecutado: true, conLock: false };
+  }
+
+  try {
+    fn();
+    return { ejecutado: true, conLock: true };
+  } finally {
+    liberar(nombre);
+  }
+}
+
 /**
  * Libera todos los locks adquiridos por este proceso.
  * Invocado por handlers de SIGTERM/SIGINT/exit.
@@ -155,5 +349,9 @@ module.exports = {
   adquirir,
   liberar,
   liberarTodos,
-  _internals: { pidVivo, rutaLock, STALE_MS_DEFAULT },
+  conLockRetry,
+  _internals: {
+    pidVivo, rutaLock, dormirSync, crearLockExclusivo, lockTomable, contenidoTomable,
+    leerLock, takeoverStaleSerializado, adquirirTokenTakeover, STALE_MS_DEFAULT,
+  },
 };

package/hooks/lib/telegram-cliente.js

@@ -117,37 +117,54 @@ function _esperar(ms) {
 /**
  * Envía un mensaje de Telegram con escape HTML, truncado y reintentos.
  *
- * Solo reintenta en errores 5xx (falla de servidor). Los errores 4xx
- * (credenciales inválidas, chat no encontrado) no se reintentan porque
- * volver a intentar no resolvería el problema.
+ * Solo reintenta en errores 5xx (falla de servidor con no-entrega confirmada).
+ * NO reintenta en:
+ *  - 4xx (credenciales inválidas, chat no encontrado): reintentar no ayuda.
+ *  - statusCode 0 (timeout o error de red): la entrega es INDETERMINADA — el
+ *    POST /sendMessage pudo LLEGAR a Telegram y solo perderse la respuesta
+ *    (ECONNRESET tras enviar). Como sendMessage NO es idempotente, reintentar
+ *    DUPLICA el mensaje. Esa era la causa raíz de la triplicación de
+ *    notificaciones (diagnóstico 2026-07-11): una conexión inestable entregaba
+ *    el mensaje 1-3 veces mientras el hook logueaba un solo "ok". Se prefiere
+ *    perder una notificación best-effort ante un fallo de red a triplicarla.
  *
  * @param {string} token   - Token del bot (`123:ABC...`).
  * @param {string} chatId  - ID numérico del chat destino.
- * @param {string} texto   - Texto del mensaje. Se escapa y trunca automáticamente.
+ * @param {string} texto   - Texto del mensaje. Por default se escapa (el llamador
+ *   pasa texto PLANO). Si el llamador ya construyó HTML válido (tags + contenido
+ *   escapado), pasar `opts.escaparContenido = false` para NO re-escapar — de lo
+ *   contrario los `<b>` se convierten en `&lt;b&gt;` y Telegram los muestra
+ *   literales (doble escape; bug 2026-07-15).
  * @param {object} [opts]  - Campos adicionales para el body de sendMessage.
+ * @param {boolean} [opts.escaparContenido=true] - Escapar HTML del texto (para
+ *   llamadores que pasan texto plano). false si el texto YA es HTML listo.
  * @returns {Promise<{ok: boolean, statusCode: number, error?: string}>}
  */
 async function enviarMensaje(token, chatId, texto, opts = {}) {
-  const textoPrepado = truncar(escaparHtml(texto), LIMITE_CHARS);
+  const { escaparContenido = true, ...payloadOpts } = opts;
+  const base = escaparContenido ? escaparHtml(texto) : String(texto);
+  const textoPrepado = truncar(base, LIMITE_CHARS);
 
   for (let intento = 0; intento < REINTENTOS_MAX; intento++) {
-    const resultado = await _intentarEnvio(token, chatId, textoPrepado, opts);
-
-    if (resultado.cuerpo === 'timeout') {
-      return { ok: false, statusCode: 0, error: 'timeout' };
-    }
+    const resultado = await _intentarEnvio(token, chatId, textoPrepado, payloadOpts);
 
     if (resultado.ok) {
       return { ok: true, statusCode: resultado.statusCode };
     }
 
+    // Entrega INDETERMINADA (timeout o error de red): NO reintentar — un
+    // reintento duplicaría un mensaje que quizá ya se entregó.
+    if (resultado.statusCode === 0) {
+      return { ok: false, statusCode: 0, error: resultado.cuerpo === 'timeout' ? 'timeout' : 'network-error' };
+    }
+
     // Errores 4xx: no reintentar (credenciales inválidas, chat inexistente, etc.)
     if (resultado.statusCode >= 400 && resultado.statusCode < 500) {
       const etiqueta = resultado.statusCode === 401 ? 'unauthorized' : `http-${resultado.statusCode}`;
       return { ok: false, statusCode: resultado.statusCode, error: etiqueta };
     }
 
-    // Error de red (statusCode 0) o 5xx: reintento con backoff exponencial
+    // Solo 5xx (falla de servidor con no-entrega): reintento con backoff.
     if (intento < REINTENTOS_MAX - 1) {
       await _esperar(BACKOFF_BASE_MS * Math.pow(2, intento));
     }

package/hooks/notificacion-telegram.js

@@ -23,6 +23,7 @@ const path = require('node:path');
 
 const { cargarConfig, estaMuted } = require('./lib/telegram-config');
 const { enviarMensaje, escaparHtml } = require('./lib/telegram-cliente');
+const { resumirParaNotificacion } = require('./lib/notificacion-formato');
 
 // ----------------------------------------------------------------
 // Utilidades de logging
@@ -121,7 +122,7 @@ function construirCampos(nombreEvento, nombreProyecto, transcriptPath, evt) {
   if (nombreEvento === 'Stop' || nombreEvento === 'SubagentStop') {
     tituloBase = nombreEvento === 'SubagentStop' ? 'Subagente terminó' : 'Claude terminó';
     subtitulo  = 'Turno completado';
-    cuerpo     = leerUltimoMensajeAsistente(transcriptPath) || 'Claude terminó el turno.';
+    cuerpo     = resumirParaNotificacion(leerUltimoMensajeAsistente(transcriptPath)) || 'Claude terminó el turno.';
 
   } else if (nombreEvento === 'Notification') {
     tituloBase = 'Claude espera respuesta';
@@ -262,14 +263,23 @@ async function run() {
     `<b>Estado:</b> ${escaparHtml(subtitulo)}\n\n` +
     `${escaparHtml(cuerpo)}`;
 
-  // Enviar notificación Telegram
+  // Enviar notificación Telegram. escaparContenido:false porque `texto` YA es
+  // HTML listo (tags <b> + contenido escapado arriba); re-escaparlo mostraría
+  // los tags literales en Telegram (doble escape, bug 2026-07-15).
   const resultado = await enviarMensaje(
     config.TELEGRAM_BOT_TOKEN,
     config.TELEGRAM_CHAT_ID,
-    texto
+    texto,
+    { escaparContenido: false }
   );
 
   log('telegram resultado', resultado.ok ? 'ok' : resultado.error);
 }
 
+// Sin gate de entrypoint: los hooks se invocan vía el wrapper
+// `node -e "require('./hooks/notificacion-telegram.js')"` de settings.json (y
+// desde los wrappers -notification/-subagent), donde require.main es undefined;
+// un gate de entrypoint dejaría el hook muerto en producción (audit
+// entrypoint-wrapper.test.js). Las funciones puras testeables viven en
+// ./lib/notificacion-formato.js.
 run().catch(e => log('run error', e && e.message));

package/hooks/preservar-estado-pre-compact.js

@@ -20,6 +20,7 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 
 // Atomic write para backups pre-compact (.planning/backups/). Si la
@@ -32,7 +33,7 @@ try {
   atomicWriteJSON = (p, o) => fs.writeFileSync(p, JSON.stringify(o, null, 2), 'utf8');
 }
 
-const CWD = process.cwd();
+const CWD = raizProyecto(process.cwd());
 
 // ---------------------------------------------------------------------------
 // Archivos de estado a preservar

package/hooks/proteccion-rutas.js

@@ -228,8 +228,62 @@ const RUTAS_PERMITIDAS_EXTERNAS = [
   path.join(os.homedir(), '.claude', 'commands'),
   // Reglas globales del usuario (modificables durante consolidación cross-proyecto)
   path.join(os.homedir(), '.claude', 'rules'),
+  // Scratchpad de sesión del harness de Claude Code (os.tmpdir()/claude/<proyecto>/<sesión>/)
+  // — el propio harness instruye usarlo para todo temporal (caso real 2026-07-10:
+  // el hook bloqueaba al agente escribiendo en su scratchpad oficial).
+  path.join(os.tmpdir(), 'claude'),
 ];
 
+/**
+ * Asciende desde `desde` buscando la raíz del repositorio git que lo contiene
+ * (directorio con `.git` — directorio normal o archivo, para worktrees).
+ *
+ * La frontera de seguridad correcta es el PROYECTO, no el subdirectorio donde
+ * se abrió la sesión: con CWD=<repo>/backend, escribir `<repo>/.planning/...`
+ * es legítimo (todo el sistema SWL escribe `.planning/` en la raíz). Caso real
+ * SIGM 2026-07-10: el loop de auditoría se auto-bloqueaba en un monorepo.
+ *
+ * @param {string} desde - Directorio inicial (típicamente el CWD).
+ * @returns {string|null} Raíz del repo, o null si `desde` no está en un repo git.
+ */
+function raizRepoGit(desde) {
+  const fs = require('fs');
+  let actual = path.resolve(desde);
+  for (let i = 0; i < 40; i++) {
+    try {
+      if (fs.existsSync(path.join(actual, '.git'))) return actual;
+    } catch (_) {
+      return null;
+    }
+    const padre = path.dirname(actual);
+    if (padre === actual) return null; // raíz del filesystem
+    actual = padre;
+  }
+  return null;
+}
+
+/**
+ * Verifica si la ruta resuelta cae dentro de la raíz del repositorio git que
+ * contiene al CWD. Boundary check por componente completo (prefijo + '/'),
+ * case-insensitive en Windows — un sibling `<repo>-evil` NO pasa.
+ *
+ * @param {string} rutaResuelta
+ * @param {string} cwdActual
+ * @returns {boolean}
+ */
+function estaDentroDeRaizGit(rutaResuelta, cwdActual) {
+  const raiz = raizRepoGit(cwdActual);
+  if (!raiz) return false;
+
+  const raizNorm = normalizarParaComparacion(raiz);
+  const rutaNorm = normalizarParaComparacion(rutaResuelta);
+  const [raizCmp, rutaCmp] = process.platform === 'win32'
+    ? [raizNorm.toLowerCase(), rutaNorm.toLowerCase()]
+    : [raizNorm, rutaNorm];
+
+  return rutaCmp === raizCmp || rutaCmp.startsWith(raizCmp + '/');
+}
+
 /**
  * Parsea la variable de entorno SWL_PROTECCION_RUTAS_PERMITIR (CSV de rutas
  * absolutas) y devuelve un array de paths normalizados.
@@ -361,7 +415,8 @@ function construirMensajeBloqueo(tipoViolacion, rutaRaw, rutaResuelta, cwdActual
     `Directorio CWD: ${cwdActual}`,
     ``,
     `Reglas de seguridad:`,
-    `  - La ruta de destino debe estar dentro del directorio de trabajo actual.`,
+    `  - La ruta de destino debe estar dentro del directorio de trabajo actual`,
+    `    o de la raíz del repositorio git que lo contiene (monorepos).`,
     `  - No se permiten secuencias de path traversal (../, ~/, %2e%2e, etc.).`,
     `  - No se permiten rutas absolutas fuera del proyecto.`,
   ];
@@ -440,9 +495,10 @@ process.stdin.on('end', () => {
       process.exit(2);
     }
 
-    // --- Verificación 2: destino dentro del CWD o en rutas externas permitidas ---
+    // --- Verificación 2: destino dentro del CWD, de la raíz del repo git
+    //     del CWD, o en rutas externas permitidas ---
     const { dentro, rutaResuelta } = verificarDentroDeCwd(rutaRaw, cwdActual);
-    if (!dentro && !esRutaExternaPermitida(rutaResuelta)) {
+    if (!dentro && !estaDentroDeRaizGit(rutaResuelta, cwdActual) && !esRutaExternaPermitida(rutaResuelta)) {
       const razon = construirMensajeBloqueo(
         `Destino fuera del directorio de trabajo actual`,
         rutaRaw,

package/hooks/registro-turnos.js

@@ -54,12 +54,13 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 
 const LIMITE_TURNOS = parseInt(process.env.SWL_REGISTRO_TURNOS_LIMITE || '1000', 10);
 const MAX_INPUT_CHARS = 200;
 const MAX_OUTPUT_CHARS = 500;
-const DIR_BASE = path.join(process.cwd(), '.planning', 'sessions');
+const DIR_BASE = path.join(raizProyecto(process.cwd()), '.planning', 'sessions');
 
 // Patrones de sanitización conservadores: tokens largos, llaves API, JWT,
 // password en URLs, paths con .env. Si aparece un match, se reemplaza con

package/hooks/resumen-sesion.js

@@ -18,6 +18,7 @@
  */
 
 const fs     = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path   = require('path');
 const os     = require('os');
 const { execFile } = require('child_process');
@@ -83,7 +84,7 @@ function hooksDisparados(sessionId) {
 
   // Fallback: heurística por archivos JSONL de hooks conocidos en .planning/
   try {
-    const planningDir = path.join(process.cwd(), '.planning');
+    const planningDir = path.join(raizProyecto(process.cwd()), '.planning');
     const jsonlCandidatos = [
       ['evolution/nudges.jsonl', 'nudge-tracker'],
       ['auto-evolution/agentes.jsonl', 'auto-evolucion'],

package/hooks/risk-scoring.js

@@ -26,6 +26,7 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 const os   = require('os');
 
@@ -104,7 +105,7 @@ function trackHighOverride(score, factors, toolName) {
   });
 
   if (state.highOverrides >= MAX_HIGH_OVERRIDES && !state.auditWritten) {
-    const auditPath = path.join(process.cwd(), '.planning', 'AUDITORIA.md');
+    const auditPath = path.join(raizProyecto(process.cwd()), '.planning', 'AUDITORIA.md');
     try {
       const auditEntry = [
         '',

package/hooks/rotar-audit-auto.js

@@ -29,16 +29,30 @@
 const fs = require('fs');
 const path = require('path');
 const { spawnSync } = require('child_process');
+const { raizProyecto } = require('./lib/raiz-proyecto');
+const guard = require('./lib/singleton-guard');
 
-const RAIZ_PROYECTO = path.resolve(__dirname, '..');
+// Ancla: raíz del PROYECTO (no __dirname/.. — en instalaciones destino el hook
+// vive en ~/.claude/hooks/ y esa ancla apuntaba a ~/.claude/, nunca al
+// proyecto; misma clase que DT-HOOKS-RAIZ-GIT).
+const RAIZ_PROYECTO = raizProyecto(process.cwd());
 const DIR_PLANNING = path.join(RAIZ_PROYECTO, '.planning');
 const ARCHIVOS_AUDIT = [
   path.join(DIR_PLANNING, 'audit.jsonl'),
   path.join(DIR_PLANNING, 'audit-merkle.jsonl'),
 ];
-const DIR_ARCHIVO = path.join(DIR_PLANNING, 'archivo', 'audit');
+const DIR_ARCHIVO = path.join(DIR_PLANNING, 'archive', 'audit');
 const MARCA_ULTIMA_ROTACION = path.join(DIR_ARCHIVO, '.ultima-rotacion');
-const SCRIPT_ROTAR = path.join(RAIZ_PROYECTO, 'scripts', 'rotar-audit-logs.js');
+// El script de rotación es EJECUTABLE de la distribución SWL: se resuelve
+// SOLO desde la ubicación instalada del hook (__dirname) — repo madre en
+// scripts/, destino aplanado junto al hook. NUNCA desde la raíz del
+// proyecto: un repo no confiable podría plantar el script y ejecutarse en
+// el primer Stop (hallazgo MAYOR revisor-seguridad 2026-07-10). Los DATOS
+// (DIR_PLANNING) sí anclan a raizProyecto.
+const SCRIPT_ROTAR = [
+  path.join(__dirname, '..', 'scripts', 'rotar-audit-logs.js'),
+  path.join(__dirname, 'rotar-audit-logs.js'),
+].find(p => { try { return fs.existsSync(p); } catch (_) { return false; } }) || '';
 
 const COOLDOWN_MS = 6 * 60 * 60 * 1000; // 6 horas
 
@@ -93,24 +107,36 @@ function main() {
   if (!check.excedido) return;
   if (enCooldown()) return;
 
-  const dias = diasRetencion();
-  const nodeBin = process.execPath;
-  const result = spawnSync(
-    nodeBin,
-    [SCRIPT_ROTAR, `--dias=${dias}`, `--raiz=${DIR_PLANNING}`],
-    { encoding: 'utf8', timeout: 30_000, cwd: RAIZ_PROYECTO }
-  );
-
-  if (result.status === 0) {
-    marcarRotacion();
-    const sizeMb = (check.size / 1024 / 1024).toFixed(1);
-    const limiteMb = (check.limite / 1024 / 1024).toFixed(1);
-    const nombreArchivo = path.basename(check.ruta);
-    const match = (result.stdout || '').match(/(\d+) archivadas/g);
-    const archivadas = match ? match.map((m) => m.replace(' archivadas', '')).join('+') : '?';
-    process.stdout.write(
-      `[rotacion-audit] ${nombreArchivo}=${sizeMb}MB > ${limiteMb}MB → archivadas ${archivadas} entradas (>${dias}d)\n`
+  // Lock cross-proceso (nemesis iter-1 S2-1/S3-4): dos sesiones con Stop
+  // simultáneo podían rotar a la vez → re-archivar las mismas entradas
+  // (duplicados en el .gz). Si otra rotación está activa, salir — esa corrida
+  // ya archiva. Ancla del lock = raíz del proyecto (misma que RAIZ_PROYECTO).
+  if (!guard.adquirir('rotar-audit', { staleMs: 300_000 })) return;
+  try {
+    const dias = diasRetencion();
+    const nodeBin = process.execPath;
+    const result = spawnSync(
+      nodeBin,
+      [SCRIPT_ROTAR, `--dias=${dias}`, `--raiz=${DIR_PLANNING}`],
+      // Archivos de auditoría de decenas de MB pueden tardar; 30s los mataba a
+      // mitad de rotación (nemesis iter-1 S3-4). 5 min da margen; el escribirActivo
+      // atómico protege contra la interrupción residual.
+      { encoding: 'utf8', timeout: 300_000, cwd: RAIZ_PROYECTO }
     );
+
+    if (result.status === 0) {
+      marcarRotacion();
+      const sizeMb = (check.size / 1024 / 1024).toFixed(1);
+      const limiteMb = (check.limite / 1024 / 1024).toFixed(1);
+      const nombreArchivo = path.basename(check.ruta);
+      const match = (result.stdout || '').match(/(\d+) archivadas/g);
+      const archivadas = match ? match.map((m) => m.replace(' archivadas', '')).join('+') : '?';
+      process.stdout.write(
+        `[rotacion-audit] ${nombreArchivo}=${sizeMb}MB > ${limiteMb}MB → archivadas ${archivadas} entradas (>${dias}d)\n`
+      );
+    }
+  } finally {
+    guard.liberar('rotar-audit');
   }
 }