@saulwade/swl-ses 2.5.2 → 2.6.0

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');
   }
 }
 

package/hooks/session-briefing.js

@@ -19,7 +19,9 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
+const { spawn } = require('child_process');
 
 // Require con fallback dual: el instalador aplana `hooks/lib/X.js → <hooks>/X.js`
 // en el destino, pero en el repo madre vive en `lib/`. Cubre ambos layouts (D-17).
@@ -32,6 +34,116 @@ function requireDual(nombre) {
   }
 }
 
+// ---------------------------------------------------------------------------
+// Fallback de disparo del ciclo autónomo (Fase 21, T-11, ADR-0041/0042,
+// REQ-21-11). El scheduler cron (`gateway/cron/jobs.example.json`) es el
+// disparador primario de la Fase A; este fallback cubre proyectos sin
+// scheduler configurado, disparando desde el propio SessionStart cuando toca.
+//
+// Fuera de alcance intencional en instalaciones destino (Fase 26): las libs
+// `scripts/lib/ciclo-autonomo/*.js` viajan en `hooks-core` (resuelven cross-dir
+// igual que `git-metricas`/`npm-version`), pero el wrapper `scripts/cli/
+// ciclo-autonomo.js` se distribuye SOLO por `package.json#files` — en destino
+// puede no resolver. Cuando no resuelve: silencio, nunca crashea el hook.
+// ---------------------------------------------------------------------------
+
+/**
+ * Resuelve la lib pura de decisión del fallback (`scripts/lib/ciclo-autonomo/
+ * fallback.js`). Dual: repo madre / destino copy-mode (`../scripts/lib/...`)
+ * vs destino aplanado (`./lib/ciclo-autonomo/fallback`, mismo criterio que
+ * `hooks/check-update.js` con `scripts/lib/npm-version.js`). Ausente → null.
+ */
+function resolverFallbackCiclo() {
+  try {
+    return require('../scripts/lib/ciclo-autonomo/fallback');
+  } catch (e1) {
+    if (e1 && e1.code !== 'MODULE_NOT_FOUND') throw e1;
+    try {
+      return require('./lib/ciclo-autonomo/fallback');
+    } catch (e2) {
+      if (e2 && e2.code !== 'MODULE_NOT_FOUND') throw e2;
+      return null;
+    }
+  }
+}
+
+/**
+ * Resuelve la ruta absoluta del wrapper CLI del ciclo
+ * (`scripts/cli/ciclo-autonomo.js`) SIN requerirlo — `require.resolve` nunca
+ * ejecuta el módulo, evita cargar en este proceso el árbol completo del ciclo
+ * (config/lock/writer/drenador/puente) solo para calcular un path.
+ */
+function resolverRutaCliCiclo() {
+  try {
+    return require.resolve('../scripts/cli/ciclo-autonomo');
+  } catch (e1) {
+    if (e1 && e1.code !== 'MODULE_NOT_FOUND') throw e1;
+    try {
+      return require.resolve('./lib/ciclo-autonomo/ciclo-autonomo');
+    } catch (e2) {
+      if (e2 && e2.code !== 'MODULE_NOT_FOUND') throw e2;
+      return null;
+    }
+  }
+}
+
+/**
+ * Dispara la Fase A del ciclo autónomo en un proceso separado
+ * (fire-and-forget, `detached` + `unref`) cuando el motor está habilitado y
+ * pasaron >=24h desde la última corrida (o nunca corrió). Guard barato
+ * PRIMERO: si no existe `.planning/evolution/ciclo-config.json`, retorna sin
+ * requerir ninguna lib del ciclo — la inmensa mayoría de proyectos nunca lo
+ * habilitó y el presupuesto de este hook (<200ms) no debe pagar ese costo.
+ * El hook NO espera el resultado; el lock propio del ciclo (T-02) garantiza
+ * que no haya doble corrida con el scheduler cron.
+ */
+function dispararCicloAutonomoSiToca(cwd, hoy) {
+  if (!fs.existsSync(path.join(cwd, '.planning', 'evolution', 'ciclo-config.json'))) return;
+
+  const fallback = resolverFallbackCiclo();
+  if (!fallback) return;
+
+  const { disparar } = fallback.debeDisparar(cwd, { ahora: hoy });
+  if (!disparar) return;
+
+  const rutaCli = resolverRutaCliCiclo();
+  if (!rutaCli) return; // no resuelve en esta instalación: silencio, nunca crashea
+
+  spawn(
+    process.execPath,
+    ['-e', `require(${JSON.stringify(rutaCli)})({})`],
+    { detached: true, stdio: 'ignore', cwd }
+  ).unref();
+}
+
+/** Texto de un archivo o `null` si no existe / no se puede leer. */
+function leerTextoSeguro(p) {
+  try {
+    return fs.readFileSync(p, 'utf8');
+  } catch (_) {
+    return null;
+  }
+}
+
+/**
+ * Línea de resumen de la última corrida del ciclo autónomo para el digest,
+ * cuando `ciclo-config.json` existe y tiene `ultima_corrida` registrada.
+ */
+function lineaResumenCiclo(cwd) {
+  const txt = leerTextoSeguro(path.join(cwd, '.planning', 'evolution', 'ciclo-config.json'));
+  if (!txt) return null;
+  let cfg;
+  try {
+    cfg = JSON.parse(txt);
+  } catch (_) {
+    return null;
+  }
+  const u = cfg && cfg.ultima_corrida;
+  if (!u) return null;
+  return `Ciclo autónomo: última corrida ${cfg.last_run || 'desconocida'} — ` +
+    `promovió ${u.promovidos || 0}, degradó ${u.degradados || 0}, drenó ${u.drenados || 0}`;
+}
+
 let briefing;
 let atomicWriteJSON;
 try {
@@ -53,7 +165,7 @@ process.stdin.on('end', () => {
     if (process.env.SWL_BRIEFING === '0') return; // opt-out
     if (!briefing) return;                          // lib ausente: degradar a silencio
 
-    const cwd = process.cwd();
+    const cwd = raizProyecto(process.cwd());
     if (!fs.existsSync(path.join(cwd, '.planning'))) return; // zero-config
 
     const hoy = new Date();
@@ -78,8 +190,22 @@ process.stdin.on('end', () => {
     const digest = briefing.armarDigest(items, estadoPrevio, dia, {
       categoriasSilenciadas: silenciadas,
     });
+
+    // Fallback de disparo del ciclo autónomo (Fase 21, T-11, REQ-21-11): aislado
+    // en su propio try/catch y evaluado ANTES del early-return de silencio total
+    // — es una acción de fondo independiente de si hay señales que mostrar hoy.
+    try {
+      dispararCicloAutonomoSiToca(cwd, hoy);
+    } catch (_) { /* fire-and-forget best-effort: nunca bloquear la sesión */ }
+
     if (!digest) return; // silencio total: sin señales nuevas
 
+    // Línea de resumen del ciclo autónomo (si hubo corrida reciente registrada).
+    try {
+      const lineaCiclo = lineaResumenCiclo(cwd);
+      if (lineaCiclo) digest.texto = `${digest.texto}\n${lineaCiclo}`;
+    } catch (_) { /* best-effort: no romper el digest por esto */ }
+
     // Persistir el estado de dedupe (best-effort).
     try {
       const dir = path.join(cwd, '.planning', 'user-profile');

package/hooks/spec-gate.js

@@ -32,6 +32,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 const crypto = require('crypto');
 
@@ -180,7 +181,7 @@ function main() {
     process.exit(0);
   }
 
-  const cwd = process.cwd();
+  const cwd = raizProyecto(process.cwd());
   const toolName = evento?.tool_name;
   const filePath = evento?.tool_input?.file_path;
 

package/hooks/sugerir-contribuir.js

@@ -33,6 +33,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 
 let isPackageRoot, readEvolutionMeta;
@@ -52,7 +53,7 @@ const CARPETAS_EVOLUCIONABLES = [
 ];
 
 const STATE_FILE = path.join(
-  process.cwd(),
+  raizProyecto(process.cwd()),
   '.planning',
   'comms',
   'sugerir-contribuir-cooldown.json'
@@ -68,7 +69,7 @@ function rutaRelativaAlProyecto(rutaRaw) {
   let normalizada = normalizarSeparadores(rutaRaw);
 
   if (path.isAbsolute(normalizada)) {
-    const cwd = normalizarSeparadores(process.cwd());
+    const cwd = normalizarSeparadores(raizProyecto(process.cwd()));
     if (normalizada.toLowerCase().startsWith(cwd.toLowerCase())) {
       normalizada = normalizada.slice(cwd.length).replace(/^\/+/, '');
     } else {
@@ -174,7 +175,9 @@ function evaluar(toolName, toolInput) {
   if (!ruta) return null;
   if (!esEvolucionable(ruta)) return null;
 
-  const rutaAbsoluta = path.isAbsolute(rutaRaw) ? rutaRaw : path.join(process.cwd(), ruta);
+  // `ruta` ya es relativa a la raíz del proyecto (rutaRelativaAlProyecto la
+  // despoja contra esa misma ancla) — reconstruir contra la raíz, no el cwd.
+  const rutaAbsoluta = path.isAbsolute(rutaRaw) ? rutaRaw : path.join(raizProyecto(process.cwd()), ruta);
   if (!fs.existsSync(rutaAbsoluta)) return null;
 
   const evo = readEvolutionMeta(rutaAbsoluta);

package/hooks/sugerir-regenerar-inventario.js

@@ -27,6 +27,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 
 // Carpetas cuyo cambio invalida los contadores de INVENTARIO.md
@@ -38,7 +39,7 @@ const CARPETAS_INVENTARIADAS = [
   { ruta: 'reglas/',       etiqueta: 'reglas' },
 ];
 
-const STATE_FILE = path.join(process.cwd(), '.planning', 'inventario-aviso-state.json');
+const STATE_FILE = path.join(raizProyecto(process.cwd()), '.planning', 'inventario-aviso-state.json');
 const COOLDOWN_MS = 30 * 60 * 1000; // 30 min
 
 function normalizarSeparadores(p) {
@@ -52,7 +53,7 @@ function detectarCarpeta(rutaRaw) {
   // Solo nos interesan rutas relativas al proyecto. Si es absoluta, intentamos
   // hacerla relativa al CWD actual.
   if (path.isAbsolute(normalizada)) {
-    const cwd = normalizarSeparadores(process.cwd());
+    const cwd = normalizarSeparadores(raizProyecto(process.cwd()));
     if (normalizada.toLowerCase().startsWith(cwd.toLowerCase())) {
       normalizada = normalizada.slice(cwd.length).replace(/^\/+/, '');
     } else {

package/hooks/tdd-gate.js

@@ -30,6 +30,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 const { execFileSync } = require('child_process');
 
@@ -209,7 +210,7 @@ function main() {
 
   if (evento?.tool_name !== 'Bash') process.exit(0);
   const comando = evento?.tool_input?.command;
-  const cwd = process.cwd();
+  const cwd = raizProyecto(process.cwd());
 
   // Zero-config: sin .planning/ no hay ciclo GSD que vigilar.
   if (!fs.existsSync(path.join(cwd, '.planning'))) process.exit(0);

package/hooks/telemetria-agentes.js

@@ -17,6 +17,7 @@
  */
 
 const { registrar } = require('./lib/otlp-exporter');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 
 // Importar esquema de spans con guard de robustez — el hook no debe fallar
 // si el módulo aún no existe en instalaciones anteriores del sistema.
@@ -27,7 +28,7 @@ try {
   // Módulo no disponible — continuar sin tipado de span
 }
 
-const CWD = process.cwd();
+const CWD = raizProyecto(process.cwd());
 
 // ---------------------------------------------------------------------------
 // Mapping de eventos a tipos de span

package/hooks/telemetria-skill-routing.js

@@ -1,5 +1,6 @@
 #!/usr/bin/env node
 'use strict';
+const { raizProyecto } = require('./lib/raiz-proyecto');
 
 /**
  * Hook: telemetria-skill-routing.js
@@ -91,7 +92,7 @@ if (!require.main || require.main === module) {
     process.stdin.on('data', (chunk) => { inputRaw += chunk; });
     process.stdin.on('end', () => {
       try {
-        procesar(JSON.parse(inputRaw), process.cwd());
+        procesar(JSON.parse(inputRaw), raizProyecto(process.cwd()));
       } catch (_) {
         // Silencioso — nunca interrumpir la sesión por un fallo de telemetría.
       }

package/hooks/tracking-costos.js

@@ -21,6 +21,7 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 const os   = require('os');
 
@@ -75,10 +76,10 @@ const PRESUPUESTO_DEFAULT = {
 };
 
 /** Ruta del manifesto de configuración de hooks. */
-const RUTA_HOOKS_CONFIG = path.join(process.cwd(), 'manifiestos', 'hooks-config.json');
+const RUTA_HOOKS_CONFIG = path.join(raizProyecto(process.cwd()), 'manifiestos', 'hooks-config.json');
 
 /** Ruta del archivo de métricas de sesión. */
-const RUTA_METRICS = path.join(process.cwd(), '.planning', 'METRICAS.md');
+const RUTA_METRICS = path.join(raizProyecto(process.cwd()), '.planning', 'METRICAS.md');
 
 // ---------------------------------------------------------------------------
 // Utilidades de configuración
@@ -673,7 +674,7 @@ process.stdin.on('end', () => {
     if (estado.toolCalls % INTERVALO_ACTUALIZACION === 0) {
       try {
         const { actualizarSesion } = require('./lib/session-store');
-        const cwd = process.cwd();
+        const cwd = raizProyecto(process.cwd());
         actualizarSesion(cwd, {
           toolCall: toolName,
           tokensEstimated: estado.tokensTotal,

package/hooks/validar-formato-post-subagente.js

@@ -23,9 +23,10 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 
-const CWD = process.cwd();
+const CWD = raizProyecto(process.cwd());
 const SCHEMAS_PATH = path.join(CWD, 'manifiestos', 'agent-output-schemas.json');
 const LOG_PATH     = path.join(CWD, '.planning', 'evolution', 'formato-violaciones.jsonl');
 

package/hooks/validar-intent-spec.js

@@ -44,6 +44,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 const crypto = require('crypto');
 
@@ -188,7 +189,7 @@ if (faltan.length === 0) {
 }
 
 // ─── Emitir nudge ─────────────────────────────────────────────────────────
-const CWD = process.cwd();
+const CWD = raizProyecto(process.cwd());
 const rutaRelativa = path.relative(CWD, filePath).replace(/\\/g, '/');
 const nombreAgente = path.basename(filePath, '.md');
 

package/hooks/validar-memoria-hook.js

@@ -34,6 +34,7 @@
  */
 
 const fs   = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 const { spawnSync } = require('child_process');
 
@@ -49,8 +50,17 @@ const ARCHIVOS_MEMORIA = [
   'instintos/global.yaml',
 ];
 
-/** Path del validador. */
-const VALIDADOR = path.join(process.cwd(), 'scripts', 'validar-memoria.js');
+/**
+ * Path del validador — EJECUTABLE de la distribución SWL: se resuelve SOLO
+ * desde la ubicación instalada del hook (__dirname), NUNCA desde el árbol
+ * del proyecto (un repo no confiable podría plantar el script; hallazgo
+ * revisor-seguridad 2026-07-10). Los DATOS que valida sí anclan a la raíz
+ * del proyecto (cwd del spawn).
+ */
+const VALIDADOR = [
+  path.join(__dirname, '..', 'scripts', 'validar-memoria.js'), // repo madre
+  path.join(__dirname, 'validar-memoria.js'),                  // destino aplanado
+].find(p => { try { return fs.existsSync(p); } catch (_) { return false; } }) || '';
 
 /** Timeout para el validador (ms). Si tarda más, se aborta sin bloquear. */
 const TIMEOUT_MS = 5000;
@@ -106,7 +116,7 @@ function ejecutarValidador() {
   if (!fs.existsSync(VALIDADOR)) return null;
   try {
     const r = spawnSync(process.execPath, [VALIDADOR, '--json'], {
-      cwd: process.cwd(),
+      cwd: raizProyecto(process.cwd()),
       encoding: 'utf8',
       timeout: TIMEOUT_MS,
       windowsHide: true,

package/hooks/validar-planning-paths.js

@@ -19,6 +19,7 @@
  */
 
 const fs = require('fs');
+const { raizProyecto } = require('./lib/raiz-proyecto');
 const path = require('path');
 const crypto = require('crypto');
 
@@ -76,7 +77,7 @@ const DIRS_CANONICOS = [
 ];
 
 // ─── Cargar allowlist (manifest si existe, embebida si no) ──────────────────
-const CWD = process.cwd();
+const CWD = raizProyecto(process.cwd());
 const allowlistPath = path.join(CWD, 'manifiestos', 'planning-paths.json');
 let permitidos;
 try {