@saulwade/swl-ses 2.5.3 → 2.6.1

package/hooks/extraccion-aprendizajes.js

@@ -31,6 +31,8 @@ const path = require('path');
 const os   = require('os');
 
 const { atomicWriteSync } = require('./lib/atomic-write');
+const { raizProyecto } = require('./lib/raiz-proyecto');
+const { conLockRetry } = require('./lib/singleton-guard');
 
 // ---------------------------------------------------------------------------
 // Constantes de configuración
@@ -38,9 +40,13 @@ const { atomicWriteSync } = require('./lib/atomic-write');
 
 /**
  * Ruta del archivo donde se acumulan los aprendizajes.
- * Se resuelve relativa al CWD del proceso (raíz del proyecto).
+ * Se re-resuelve en el entrypoint con la RAÍZ DEL PROYECTO (raizProyecto:
+ * primer .planning/ real ascendiendo, o raíz del repo git, o fallback cwd) —
+ * NUNCA con el CWD crudo de la sesión: en monorepos con sesión abierta en un
+ * subdirectorio eso fragmentaba la memoria en árboles .planning/ huérfanos
+ * (DT-HOOKS-RAIZ-GIT, reportes de campo sigm + oic 2026-07-10).
  */
-const RUTA_APRENDIZAJES = path.join(process.cwd(), '.planning', 'APRENDIZAJES.md');
+let RUTA_APRENDIZAJES = path.join(raizProyecto(process.cwd()), '.planning', 'APRENDIZAJES.md');
 
 /**
  * Número de líneas de contexto a extraer alrededor del keyword detectado.
@@ -364,9 +370,15 @@ function extraerTextoYAgente(data) {
  *   4. Clasificar por el tipo de keyword que disparó la detección.
  *
  * @param {string} texto
+ * @param {object} [opts]
+ * @param {boolean} [opts.descartarFragmentos=false] - Descarta candidatos cuya
+ *   descripción quedó TRUNCADA a media frase (termina en '…' sin oración
+ *   completa). Obligatorio para fuentes Write/Edit: los comentarios de código
+ *   de dominio largos producían entradas cortadas a medias que no son
+ *   aprendizajes (reporte de campo sigm 2026-07-10).
  * @returns {Aprendizaje|null}
  */
-function detectarAprendizaje(texto) {
+function detectarAprendizaje(texto, opts = {}) {
   if (!texto || texto.trim().length < MIN_CHARS_DESCRIPCION) return null;
 
   const lineas = texto.split('\n');
@@ -395,12 +407,28 @@ function detectarAprendizaje(texto) {
         // Descripción: la línea del keyword, limpiada de símbolos de código.
         // Preferir cortar al final de la primera oración si cabe en 120 chars;
         // si no, al último espacio antes del límite.
-        const lineaLimpia = lineas[i]
+        const limpiarLinea = l => l
           .trim()
           .replace(/^[#*\/\-–•]+\s*/, '') // Quitar prefijos de comentario/lista
           .replace(/\*\*/g, '')            // Quitar marcadores de negrita Markdown
           .replace(/`+/g, '');             // Quitar backticks
 
+        let lineaLimpia = limpiarLinea(lineas[i]);
+
+        // Wrap del editor ≠ fin del pensamiento: si la línea del keyword no
+        // cierra oración, unir hasta 2 líneas siguientes antes de buscar el
+        // corte — los comentarios largos envuelven la frase y cortar en el
+        // wrap producía títulos a media frase (ticket de campo sigm
+        // 2026-07-10: "...pueden cerrar la 'corrección' apuntando a").
+        if (!/[.!?]/.test(lineaLimpia)) {
+          for (let j = i + 1; j < Math.min(i + 3, lineas.length); j++) {
+            const continuacion = limpiarLinea(lineas[j]);
+            if (!continuacion) break;
+            lineaLimpia += ' ' + continuacion;
+            if (/[.!?]/.test(continuacion)) break;
+          }
+        }
+
         // Si la línea tiene un punto temprano, usarlo como fin natural
         const matchOracion = lineaLimpia.match(/^[^.!?]*[.!?]/);
         const descripcionBase = matchOracion
@@ -411,6 +439,12 @@ function detectarAprendizaje(texto) {
 
         if (descripcion.length < 10) continue;
 
+        // Fragmento a media frase: ni la línea ni sus continuaciones cierran
+        // oración Y hubo que truncar — para fuentes de escritura de código
+        // eso es ruido. Una oración completa truncada elegante (corte en
+        // frontera de cláusula con '…') SÍ es título legítimo.
+        if (opts.descartarFragmentos && !matchOracion && descripcion.endsWith('…')) continue;
+
         return { tipo, contexto: contextoFinal, descripcion };
       }
     }
@@ -540,6 +574,27 @@ function formatearEntrada(fecha, tipo, descripcion, agente, contexto) {
  * @param {string} agente
  */
 function escribirAprendizaje(aprendizaje, agente) {
+  // Read-modify-write sobre APRENDIZAJES.md (leer todo → dedup → reescribir
+  // todo). Dos hooks concurrentes leían la misma base y el segundo write
+  // pisaba la entrada del primero → aprendizaje perdido (nemesis S2-2).
+  // El lock O_EXCL serializa el CASO COMÚN (secciones críticas de <<1s): dos
+  // hooks casi-simultáneos se ordenan, sin pérdida. La lectura ocurre DENTRO de
+  // la sección crítica para ver base fresca.
+  //
+  // Límite honesto (re-auditoría nemesis iter-2): siNoAdquiere:'ejecutar'
+  // significa que si tras maxWaitMs NO se adquiere el lock —solo posible con un
+  // holder VIVO ocupando el lock >1s, patológico para un archivo de KB (un
+  // holder muerto se reclama al instante vía pidVivo)— se corre igual SIN lock.
+  // En ese caso extremo el rewrite-whole-file PUEDE pisar la entrada de otro
+  // proceso. Se prefiere ese riesgo casi-inalcanzable a OMITIR y descartar el
+  // aprendizaje actual con certeza.
+  conLockRetry('extraccion-aprendizajes-md', () => _escribirAprendizajeInterno(aprendizaje, agente), {
+    maxWaitMs: 1000,
+    siNoAdquiere: 'ejecutar',
+  });
+}
+
+function _escribirAprendizajeInterno(aprendizaje, agente) {
   asegurarDirectorio();
 
   const { contenidoExistente, descripciones } = leerAprendizajesExistentes();
@@ -676,6 +731,11 @@ const PATRONES_ARCHIVO_SWL_EXCLUIDO = [
   // "rules" (inglés). Detectado 2026-06-11: fragmentos de una edición a
   // verificar-citas-normativas.md (global) se promovieron como "patrón".
   /(?:^|[\\/])\.claude[\\/]rules[\\/]/,
+  // Workflows y config de CI (.github/): sus comentarios YAML describen el
+  // proceso con keywords narrativas ("decisión", "aprobación") que el hook
+  // confunde con descubrimientos. Detectado 2026-07-10: el comentario del
+  // environment de publish-npm.yml se promovió como entrada "decisión".
+  /(?:^|[\\/])\.github[\\/]/,
 ];
 
 /**
@@ -715,6 +775,16 @@ function pareceContenidoEstructuralSwl(contexto) {
     return true;
   }
 
+  // Bold-labels de docs sin cuerpo: líneas que son SOLO una etiqueta en
+  // negritas ("**Uso:**", "**¿Cuándo usarlo?**"), con o sin valor corto de
+  // código a continuación. Junto con los headings (abajo) cubren fragmentos
+  // estructurales de manuales/skills que el hook confundía con aprendizajes
+  // (detectado 2026-07-10: headings y labels de MANUAL_USO promovidos como
+  // "gotcha"/"patrón").
+  const esLineaEstructural = l =>
+    /^(>\s*)?#{1,6}\s+\S/.test(l) ||
+    /^(>\s*)?\*\*[^*]{1,60}\*\*:?\s*(`[^`]*`\s*)?$/.test(l);
+
   // Enumeración de encabezados sin cuerpo sustantivo
   // (3+ líneas tipo "## [fecha] tipo — descripción" juntas)
   const encabezadosFecha = lineas.filter(l => /^##\s+\[\d{4}-\d{2}-\d{2}\]/.test(l));
@@ -722,15 +792,15 @@ function pareceContenidoEstructuralSwl(contexto) {
     return true;
   }
 
-  // Contexto compuesto mayoritariamente de headings sin cuerpo. Detecta
-  // placeholders auto-generados al hacer Write de archivos meta (RELEASE-NOTES,
-  // RESUMEN, PLAN) cuya estructura es solo `## Sección 1`, `## Sección 2`...
-  // sin párrafos sustantivos. Acepta tanto headings desnudos (`## Titulo`)
-  // como indentados como blockquote (`> ## Titulo`) porque el hook envuelve
-  // el contexto con `> ` antes de evaluar el resultado.
+  // Contexto compuesto mayoritariamente de headings/bold-labels sin cuerpo.
+  // Detecta placeholders auto-generados al hacer Write de archivos meta
+  // (RELEASE-NOTES, RESUMEN, PLAN) y fragmentos de docs de comandos cuya
+  // estructura es solo `## Sección`, `**Uso:**`... sin párrafos sustantivos.
+  // Acepta tanto líneas desnudas como indentadas como blockquote (`> ## X`)
+  // porque el hook envuelve el contexto con `> ` antes de evaluar.
   if (noVacias.length >= 3) {
-    const headings = noVacias.filter(l => /^(>\s*)?#{1,6}\s+\S/.test(l));
-    if (headings.length / noVacias.length > 0.6) {
+    const estructurales = noVacias.filter(esLineaEstructural);
+    if (estructurales.length / noVacias.length > 0.6) {
       return true;
     }
   }
@@ -781,15 +851,36 @@ process.stdin.on('end', () => {
       return;
     }
 
+    // Anclar la memoria a la RAÍZ DEL PROYECTO, no al CWD de la sesión
+    // (DT-HOOKS-RAIZ-GIT): una sesión abierta en backend/ de un monorepo
+    // escribía backend/.planning/APRENDIZAJES.md huérfano.
+    const baseCwd = String(data.cwd || process.cwd());
+    const raiz = raizProyecto(baseCwd);
+    RUTA_APRENDIZAJES = path.join(raiz, '.planning', 'APRENDIZAJES.md');
+
+    const esFuenteEscritura =
+      toolName === 'Write' || toolName === 'Edit' || toolName === 'MultiEdit';
+
     // Filtrar Write/Edit sobre archivos del sistema SWL (auto-referencia).
     // Editar habilidades/, agentes/, reglas/, CHANGELOG, CLAUDE.md, etc. es
     // mantenimiento del sistema, no descubrimiento en tiempo de ejecución.
-    if (toolName === 'Write' || toolName === 'Edit' || toolName === 'MultiEdit') {
+    if (esFuenteEscritura) {
       const toolInput = data.tool_input || data.tool?.input || {};
       const filePath = String(toolInput.file_path || toolInput.path || '');
       if (esArchivoSwlExcluido(filePath)) {
         return;
       }
+      // Escrituras FUERA de la raíz del proyecto (scratchpad del harness,
+      // temp, otros repos) no son descubrimiento de ESTE proyecto — su
+      // contenido meta (borradores, docs en construcción) generaba entradas
+      // espurias (detectado 2026-07-10 con archivos de trabajo en scratchpad).
+      if (filePath) {
+        const abs = path.resolve(baseCwd, filePath);
+        const rel = path.relative(raiz, abs);
+        if (rel.startsWith('..') || path.isAbsolute(rel)) {
+          return;
+        }
+      }
     }
 
     // Extraer texto y nombre del agente del payload
@@ -800,8 +891,11 @@ process.stdin.on('end', () => {
       return;
     }
 
-    // Detectar aprendizaje en el texto
-    const aprendizaje = detectarAprendizaje(texto);
+    // Detectar aprendizaje en el texto. Las fuentes de escritura de código
+    // exigen descripción con oración completa (sin fragmentos truncados).
+    const aprendizaje = detectarAprendizaje(texto, {
+      descartarFragmentos: esFuenteEscritura,
+    });
 
     if (!aprendizaje) {
       // Sin aprendizaje detectado — salir silenciosamente

package/hooks/grafo-contexto.js

@@ -19,9 +19,10 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 
-const CWD         = process.env.PWD || process.cwd();
+const CWD         = raizProyecto(process.env.PWD || process.cwd());
 const REPORT_FILE = path.join(CWD, '.planning', 'REPORTE-GRAFO.md');
 const GRAPH_FILE  = path.join(CWD, '.planning', 'graph.json');
 

package/hooks/guardrail-modelo.js

@@ -23,6 +23,7 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 
 // ---------------------------------------------------------------------------
@@ -42,7 +43,7 @@ if (ES_ENTRYPOINT && !process.env.SWL_GUARDRAIL_MODELO) {
 // Rutas
 // ---------------------------------------------------------------------------
 
-const CWD          = process.cwd();
+const CWD          = raizProyecto(process.cwd());
 const DIR_EVOL     = path.join(CWD, '.planning', 'evolution');
 const GUARDRAIL_LOG = path.join(DIR_EVOL, 'guardrail-observaciones.jsonl');
 

package/hooks/inbox-aviso.js

@@ -16,6 +16,7 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 
 const INBOX_DIR = '.planning/inbox';
@@ -51,7 +52,7 @@ process.stdin.on('end', () => {
   try {
     if (process.env.SWL_INBOX_AVISO === '0') return;
 
-    const { total, preview } = contarPendientes(process.cwd());
+    const { total, preview } = contarPendientes(raizProyecto(process.cwd()));
     if (total === 0) return;
 
     const lineas = [];

package/hooks/inyeccion-contexto.js

@@ -23,6 +23,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 const os = require('os');
 
@@ -205,7 +206,7 @@ process.stdin.on('end', () => {
       return;
     }
 
-    const cwd = process.cwd();
+    const cwd = raizProyecto(process.cwd());
     const sesion = leerSesionAnterior(cwd);
 
     // Solo inyectar si la sesion anterior tiene contenido util

package/hooks/lib/agent-matcher.js

@@ -16,6 +16,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path = require('path');
 
 // ---------------------------------------------------------------------------
@@ -123,7 +124,7 @@ function loadAgents(agentesDir) {
  * @returns {Array<{name: string, score: number, skills: string[]}>} Ordenado por score descendente.
  */
 function matchAgents(taskText, agentesDir) {
-  const dir = agentesDir || path.join(process.cwd(), 'agentes');
+  const dir = agentesDir || path.join(raizProyecto(process.cwd()), 'agentes');
   const agents = loadAgents(dir);
   const taskKeywords = extractKeywords(taskText);
 

package/hooks/lib/agent-routing.js

@@ -25,6 +25,7 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path = require('path');
 
 const _cache = Object.create(null);
@@ -38,7 +39,7 @@ const _cache = Object.create(null);
  * @returns {string|null}    - Ruta absoluta o null si no existe
  */
 function resolveAgentPath(agentName, cwd) {
-  const baseDir = cwd || process.cwd();
+  const baseDir = cwd || raizProyecto(process.cwd());
   const candidates = [
     path.join(baseDir, 'agentes', `${agentName}.md`),
     path.join(baseDir, '.claude', 'agents', `${agentName}.md`),

package/hooks/lib/autonomia.js

@@ -22,6 +22,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path = require('path');
 const { execFileSync } = require('child_process');
 
@@ -89,7 +90,7 @@ function _normalizarNivel(valor) {
  * @returns {{version?:string, defaults?:string, clases:Object}}
  */
 function cargarDial(baseDir) {
-  const ruta = path.join(baseDir || process.cwd(), ...YAML_PATH);
+  const ruta = path.join(baseDir || raizProyecto(process.cwd()), ...YAML_PATH);
   let parsed = {};
   try {
     parsed = _parsearYamlPlano(fs.readFileSync(ruta, 'utf8'));
@@ -153,7 +154,7 @@ function _archivosModificados(baseDir) {
 const MAX_ACCION_LEN = 512; // tope para que el JSONL no crezca sin límite
 
 function autoCheckpoint(baseDir, accion, tsISO) {
-  const base = baseDir || process.cwd();
+  const base = baseDir || raizProyecto(process.cwd());
   const registro = {
     ts: tsISO || new Date().toISOString(),
     accion: String(accion || '').slice(0, MAX_ACCION_LEN),
@@ -186,7 +187,7 @@ function _parseAccion(args) {
 
 function main(argv) {
   const accion = _parseAccion(argv.slice(2));
-  const baseDir = process.cwd();
+  const baseDir = raizProyecto(process.cwd());
   const dial = cargarDial(baseDir);
   if (requiereAutoCheckpoint(dial, 'cambio_reversible')) {
     const reg = autoCheckpoint(baseDir, accion || '(sin descripción)');
@@ -204,5 +205,6 @@ module.exports = {
   cargarDial,
   requiereAutoCheckpoint,
   autoCheckpoint,
+  main,
   _parsearYamlPlano,
 };

package/hooks/lib/captura-acciones.js

@@ -27,6 +27,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path = require('path');
 const crypto = require('crypto');
 
@@ -384,7 +385,7 @@ module.exports = {
 if (require.main === module) {
   try {
     if (process.argv.includes('--conteo')) {
-      process.stdout.write(JSON.stringify(contarPorSubtipo(process.cwd()), null, 2) + '\n');
+      process.stdout.write(JSON.stringify(contarPorSubtipo(raizProyecto(process.cwd())), null, 2) + '\n');
     }
   } catch (_) {
     /* exit 0 siempre */

package/hooks/lib/consolidation-lock.js

@@ -67,11 +67,18 @@ function isPidAlive(pid) {
 
 /**
  * Ruta del lock file.
+ *
  * @param {string} baseDir - Raíz del proyecto.
+ * @param {object} [opts] - Opciones.
+ * @param {string} [opts.lockFilename] - Nombre de archivo alterno al default
+ *   `.consolidation-lock`. Permite a otros consumidores (ej. el ciclo
+ *   autónomo, Fase 21 T-02) usar un lockfile propio sin colisionar con el
+ *   de auto-consolidación, reutilizando el mismo patrón PID+staleness.
  * @returns {string}
  */
-function lockPath(baseDir) {
-  return path.join(baseDir, '.planning', LOCK_FILENAME);
+function lockPath(baseDir, opts = {}) {
+  const filename = (opts && opts.lockFilename) || LOCK_FILENAME;
+  return path.join(baseDir, '.planning', filename);
 }
 
 // ---------------------------------------------------------------------------
@@ -82,10 +89,11 @@ function lockPath(baseDir) {
  * Obtiene el timestamp de la última consolidación exitosa.
  *
  * @param {string} baseDir - Raíz del proyecto.
+ * @param {object} [opts] - Ver {@link lockPath}.
  * @returns {number} Epoch ms de la última consolidación, 0 si nunca.
  */
-function getLastConsolidatedAt(baseDir) {
-  const lp = lockPath(baseDir);
+function getLastConsolidatedAt(baseDir, opts = {}) {
+  const lp = lockPath(baseDir, opts);
   try {
     const stat = fs.statSync(lp);
     return stat.mtimeMs;
@@ -150,12 +158,13 @@ function countNewSessions(baseDir) {
  * Intenta adquirir el lock de consolidación.
  *
  * @param {string} baseDir
+ * @param {object} [opts] - Ver {@link lockPath}.
  * @returns {{ acquired: boolean, priorMtime: number }}
  *   acquired: true si el lock fue adquirido
  *   priorMtime: mtime anterior (para rollback)
  */
-function tryAcquireLock(baseDir) {
-  const lp = lockPath(baseDir);
+function tryAcquireLock(baseDir, opts = {}) {
+  const lp = lockPath(baseDir, opts);
   const dir = path.dirname(lp);
 
   // Asegurar directorio
@@ -200,9 +209,10 @@ function tryAcquireLock(baseDir) {
  * Libera el lock actualizando el mtime a "ahora" (consolidación exitosa).
  *
  * @param {string} baseDir
+ * @param {object} [opts] - Ver {@link lockPath}.
  */
-function releaseLock(baseDir) {
-  const lp = lockPath(baseDir);
+function releaseLock(baseDir, opts = {}) {
+  const lp = lockPath(baseDir, opts);
   try {
     // Actualizar mtime a ahora = "última consolidación fue ahora"
     const now = Date.now() / 1000;
@@ -216,9 +226,10 @@ function releaseLock(baseDir) {
  *
  * @param {string} baseDir
  * @param {number} priorMtime - Epoch ms del mtime anterior.
+ * @param {object} [opts] - Ver {@link lockPath}.
  */
-function rollbackLock(baseDir, priorMtime) {
-  const lp = lockPath(baseDir);
+function rollbackLock(baseDir, priorMtime, opts = {}) {
+  const lp = lockPath(baseDir, opts);
   try {
     if (priorMtime === 0) {
       // No había lock antes → eliminar

package/hooks/lib/etapa-auto-evolucion.js

@@ -40,6 +40,7 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path = require('path');
 
 // Escritura atómica obligatoria para estado mutable (regla CLAUDE.md).
@@ -74,9 +75,13 @@ try {
 
 let driftDetector;
 try {
-  driftDetector = require('../scripts/lib/drift-detector');
+  driftDetector = require('../scripts/lib/drift-detector'); // repo madre
 } catch {
-  driftDetector = null;
+  try {
+    driftDetector = require('./drift-detector'); // destino: scripts/lib → hooks/lib (siblings)
+  } catch {
+    driftDetector = null;
+  }
 }
 
 let agentRouting;
@@ -105,8 +110,9 @@ const VENTANA_DIAS         = 14;
 const MIN_TOOL_CALLS       = 5;   // por debajo se considera trivial
 const MIN_INVOCACIONES_LOOP = 6;  // mínimo para que el ratio de convergencia sea significativo
 
-const DIR_AUTOEVOL  = path.join(process.cwd(), '.planning', 'auto-evolution');
-const DIR_TRACES    = path.join(process.cwd(), '.planning', 'traces');
+const RAIZ = raizProyecto(process.cwd()); // una sola resolución por proceso
+const DIR_AUTOEVOL  = path.join(RAIZ, '.planning', 'auto-evolution');
+const DIR_TRACES    = path.join(RAIZ, '.planning', 'traces');
 const LOG_PATH      = path.join(DIR_AUTOEVOL, 'agentes.jsonl');
 const NUDGES_PATH   = path.join(DIR_AUTOEVOL, 'nudges.json');
 

package/hooks/lib/etapa-metricas.js

@@ -20,6 +20,7 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path = require('path');
 
 let atomicWriteJSON;
@@ -36,7 +37,7 @@ try {
   nudgeTracker = null;
 }
 
-const CWD = process.cwd();
+const CWD = raizProyecto(process.cwd());
 const DIR_EVOL = path.join(CWD, '.planning', 'evolution');
 const METRICAS_PATH = path.join(DIR_EVOL, 'metricas.json');
 const INSTINTOS_PROYECTO = path.join(CWD, 'instintos', 'proyecto.yaml');

package/hooks/lib/etapa-perfil-usuario.js

@@ -28,6 +28,8 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
+const { conLockRetry } = require('./singleton-guard');
 const path = require('path');
 
 let atomicWriteJSON;
@@ -60,11 +62,14 @@ try {
 // ---------------------------------------------------------------------------
 
 const UMBRAL_NUDGE = parseInt(process.env.SWL_PERFIL_UMBRAL || '3', 10);
-const DIR_PERFIL   = path.join(process.cwd(), '.planning', 'user-profile');
+// Una sola resolución de la raíz por carga del módulo — las 4 rutas comparten
+// ancla; resolverla 4 veces repetía el walk ascendente con su I/O (nemesis S2-3).
+const RAIZ = raizProyecto(process.cwd());
+const DIR_PERFIL   = path.join(RAIZ, '.planning', 'user-profile');
 const DIRTY_PATH   = path.join(DIR_PERFIL, 'dirty.json');
-const PERFIL_PATH  = path.join(process.cwd(), 'instintos', 'perfil-usuario.yaml');
-const APRENDIZAJES_PATH = path.join(process.cwd(), '.planning', 'APRENDIZAJES.md');
-const INSTINTOS_PATH    = path.join(process.cwd(), 'instintos', 'proyecto.yaml');
+const PERFIL_PATH  = path.join(RAIZ, 'instintos', 'perfil-usuario.yaml');
+const APRENDIZAJES_PATH = path.join(RAIZ, '.planning', 'APRENDIZAJES.md');
+const INSTINTOS_PATH    = path.join(RAIZ, 'instintos', 'proyecto.yaml');
 
 // Keywords de corrección (señal fuerte: el usuario está corrigiendo)
 const KEYWORDS_CORRECCION = [
@@ -237,6 +242,17 @@ function extraerPromptsUsuario(inputRaw) {
  * @param {string} inputRaw transcripción de la sesión (payload del hook Stop)
  */
 function ejecutar(inputRaw) {
+  // El cuerpo hace read-modify-write sobre dirty.json (leerDirty → mutar →
+  // escribirDirty). Dos hooks Stop casi-simultáneos podían pisar el contador
+  // (nemesis S2-2). Serializar con lock; bajo contención se OMITE — perder un
+  // incremento de señal es aceptable (la próxima sesión re-dispara).
+  conLockRetry('etapa-perfil-usuario', () => _ejecutarInterno(inputRaw), {
+    maxWaitMs: 500,
+    siNoAdquiere: 'omitir',
+  });
+}
+
+function _ejecutarInterno(inputRaw) {
   try {
     const textoUsuario = extraerPromptsUsuario(inputRaw);
 

package/hooks/lib/evolution-tracker.js

@@ -17,6 +17,7 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path = require('path');
 
 // Escritura atómica obligatoria (regla CLAUDE.md). Fallback defensivo.
@@ -248,7 +249,7 @@ function _readSidecar(filePath) {
  * @returns {boolean}
  */
 function isPackageRoot(cwd) {
-  const dir = cwd || process.cwd();
+  const dir = cwd || raizProyecto(process.cwd());
   try {
     const pkgPath = path.join(dir, 'package.json');
     if (!fs.existsSync(pkgPath)) return false;

package/hooks/lib/gateway-notify.js

@@ -18,6 +18,7 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path = require('path');
 const { atomicWriteJSON } = require('./atomic-write');
 
@@ -35,6 +36,19 @@ try {
 const COMMS_DIR = '.planning/comms';
 const CONFIG_PATH = 'manifiestos/gateway-config.json';
 
+// Memo de la raíz del proyecto POR cwd: una notificación consulta config +
+// comms en la misma invocación — sin memo el walk ascendente de raizProyecto
+// se repetiría 3 veces con su I/O de existsSync. La clave por cwd evita
+// congelar la raíz cuando el proceso cambia de directorio (tests, daemons).
+let _raizCache = null;
+function raizBase() {
+  const cwd = process.cwd();
+  if (!_raizCache || _raizCache.cwd !== cwd) {
+    _raizCache = { cwd, raiz: raizProyecto(cwd) };
+  }
+  return _raizCache.raiz;
+}
+
 /** Receptores reconocidos para formato de deep link. */
 const RECEPTORES = new Set(['telegram', 'discord', 'slack', 'email', 'plain']);
 
@@ -44,7 +58,7 @@ const RECEPTORES = new Set(['telegram', 'discord', 'slack', 'email', 'plain']);
  */
 function gatewayHabilitado() {
   try {
-    const cfgPath = path.join(process.cwd(), CONFIG_PATH);
+    const cfgPath = path.join(raizBase(), CONFIG_PATH);
     if (!fs.existsSync(cfgPath)) return false;
     const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
     return cfg && cfg.enabled === true;
@@ -61,7 +75,7 @@ function gatewayHabilitado() {
  */
 function tipoHabilitado(tipo) {
   try {
-    const cfgPath = path.join(process.cwd(), CONFIG_PATH);
+    const cfgPath = path.join(raizBase(), CONFIG_PATH);
     if (!fs.existsSync(cfgPath)) return true;
     const cfg = JSON.parse(fs.readFileSync(cfgPath, 'utf8'));
     const map = cfg.notifications || {};
@@ -139,7 +153,7 @@ function notificarGateway(params) {
     if (!gatewayHabilitado()) return false;
     if (!tipoHabilitado(params.tipo)) return false;
 
-    const commsDir = path.join(process.cwd(), COMMS_DIR);
+    const commsDir = path.join(raizBase(), COMMS_DIR);
     if (!fs.existsSync(commsDir)) {
       fs.mkdirSync(commsDir, { recursive: true });
     }

package/hooks/lib/loop-telemetry.js

@@ -29,6 +29,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./raiz-proyecto');
 const path = require('path');
 const { atomicWriteSync, atomicWriteJSON } = require('./atomic-write');
 
@@ -60,11 +61,11 @@ function timestampCompacto(fecha) {
  * @param {string} opciones.tipo - Identificador del loop (ej: 'autoresearch', 'nemesis', 'verificar').
  * @param {string} [opciones.direccion='higher_is_better'] - Dirección de la métrica.
  * @param {string[]} [opciones.columnas] - Columnas del TSV (default COLUMNAS_DEFAULT).
- * @param {string} [opciones.raiz=process.cwd()] - Raíz del proyecto.
+ * @param {string} [opciones.raiz=raizProyecto(process.cwd())] - Raíz del proyecto.
  * @param {object} [opciones.config={}] - Config inicial persistida en meta.json.
  * @returns {{dir: string, tsvPath: string}}
  */
-function iniciarCorrida({ tipo, direccion = 'higher_is_better', columnas, raiz = process.cwd(), config = {} }) {
+function iniciarCorrida({ tipo, direccion = 'higher_is_better', columnas, raiz = raizProyecto(process.cwd()), config = {} }) {
   if (!tipo || !/^[a-z0-9-]+$/.test(tipo)) {
     throw new TypeError(`loop-telemetry: tipo inválido "${tipo}" — usar kebab-case (ej: "autoresearch")`);
   }
@@ -269,12 +270,12 @@ function leerHandoff(dir) {
  * Encuentra la corrida activa más reciente: directorio en .planning/loops/
  * cuyo iteraciones.tsv fue modificado hace menos de maxEdadMin minutos.
  *
- * @param {string} [raiz=process.cwd()]
+ * @param {string} [raiz=raizProyecto(process.cwd())]
  * @param {object} [opciones]
  * @param {number} [opciones.maxEdadMin=30]
  * @returns {{dir: string, tipo: string, ultimasFilas: object[], totalFilas: number}|null}
  */
-function corridaActiva(raiz = process.cwd(), { maxEdadMin = 30 } = {}) {
+function corridaActiva(raiz = raizProyecto(process.cwd()), { maxEdadMin = 30 } = {}) {
   const base = path.join(raiz, DIR_LOOPS);
   let candidatos;
   try {