@saulwade/swl-ses 2.2.4 → 2.3.1

package/hooks/contexto-iteracion.js

@@ -1,144 +1,144 @@
-#!/usr/bin/env node
-'use strict';
-
-/**
- * Hook: contexto-iteracion.js
- * Tipo: UserPromptSubmit (matcher vacío)
- *
- * Anti-context-rot para loops iterativos: cuando hay una corrida activa en
- * .planning/loops/ (autoresearch, nemesis --remediar, verificar
- * --until-converge, debate adversarial), inyecta al contexto un bloque
- * compacto con el estado del loop — iteración actual, últimas 3 filas del
- * TSV y la recomendación de trayectoria (continuar / detener por plateau /
- * cambiar estrategia).
- *
- * En sesiones largas el modelo pierde de vista en qué iteración va y si la
- * métrica sigue mejorando; este hook re-ancla ese estado sin que el agente
- * tenga que releer archivos. Patrón adoptado del análisis de autoresearch
- * v2.1 (hook iteration-context), adaptado a SWL: estado en el directorio de
- * la corrida (no /tmp) y throttle por tiempo (no por conteo de prompts).
- *
- * Throttle: máximo 1 inyección cada 4 minutos por corrida (estado en
- * .inject-state.json dentro del directorio de la corrida — se limpia solo
- * con la corrida). 4 min < TTL del prompt cache (5 min): la inyección no
- * coincide dos veces dentro de la misma ventana de cache.
- *
- * Zero-deps (solo hooks/lib/loop-telemetry). Nunca bloquea.
- * Opt-out: SWL_CONTEXTO_ITERACION=0
- */
-
-const fs = require('fs');
-const path = require('path');
-
-const { atomicWriteJSON } = require('./lib/atomic-write');
-const { corridaActiva, analizarTrayectoria } = require('./lib/loop-telemetry');
-
-/** Intervalo mínimo entre inyecciones para la misma corrida (4 minutos). */
-const THROTTLE_MS = 4 * 60 * 1000;
-
-const ARCHIVO_ESTADO = '.inject-state.json';
-
-/**
- * Decide si toca inyectar según el estado de throttle de la corrida.
- * @param {string} dirCorrida - Directorio de la corrida activa.
- * @param {number} [ahora=Date.now()]
- * @returns {boolean}
- */
-function debeInyectar(dirCorrida, ahora = Date.now()) {
-  try {
-    const estado = JSON.parse(
-      fs.readFileSync(path.join(dirCorrida, ARCHIVO_ESTADO), 'utf8')
-    );
-    return ahora - (estado.ultimaInyeccion || 0) > THROTTLE_MS;
-  } catch {
-    return true; // sin estado = primera inyección
-  }
-}
-
-/** Registra la inyección para el throttle. Best-effort, escritura atómica. */
-function registrarInyeccion(dirCorrida, ahora = Date.now()) {
-  try {
-    atomicWriteJSON(
-      path.join(dirCorrida, ARCHIVO_ESTADO),
-      { ultimaInyeccion: ahora }
-    );
-  } catch { /* silencioso */ }
-}
-
-/**
- * Construye el bloque de contexto a inyectar.
- * @param {{dir: string, tipo: string, ultimasFilas: object[], totalFilas: number}} activa
- * @param {object} trayectoria - Resultado de analizarTrayectoria.
- * @returns {string}
- */
-function construirBloque(activa, trayectoria) {
-  const lineas = [];
-  lineas.push(`🔁 Loop activo: \`${activa.tipo}\` (${path.basename(activa.dir)})`);
-  lineas.push(
-    `Iteraciones: ${trayectoria.totalIteraciones} | keep: ${trayectoria.keeps} | ` +
-    `revert: ${trayectoria.reverts} | métrica: ${trayectoria.metricaInicial} → ${trayectoria.metricaFinal}`
-  );
-
-  if (activa.ultimasFilas.length > 0) {
-    lineas.push('Últimas iteraciones:');
-    for (const fila of activa.ultimasFilas) {
-      const desc = (fila.descripcion || '').slice(0, 80);
-      lineas.push(`  ${fila.iteracion ?? '?'}. [${fila.estado || '?'}] métrica=${fila.metrica ?? '?'} — ${desc}`);
-    }
-  }
-
-  if (trayectoria.plateau) {
-    lineas.push(
-      '⚠️ PLATEAU detectado: las últimas iteraciones no mejoran la métrica. ' +
-      'Considera cerrar el loop y reportar el mejor estado alcanzado en lugar de seguir iterando.'
-    );
-  } else {
-    lineas.push(`Recomendación de trayectoria: ${trayectoria.recomendacion}.`);
-  }
-  lineas.push(`Registro completo: ${path.join(activa.dir, 'iteraciones.tsv')}`);
-
-  return lineas.join('\n');
-}
-
-// ---------------------------------------------------------------------------
-// Entrypoint
-// ---------------------------------------------------------------------------
-
-function main() {
-  let inputRaw = '';
-  process.stdin.on('data', (c) => { inputRaw += c; });
-
-  process.stdin.on('end', () => {
-    try {
-      if (process.env.SWL_CONTEXTO_ITERACION === '0') return;
-
-      const activa = corridaActiva(process.cwd(), { maxEdadMin: 30 });
-      if (!activa) return;
-      if (!debeInyectar(activa.dir)) return;
-
-      const trayectoria = analizarTrayectoria(activa.dir);
-      // Sin iteraciones más allá del baseline no hay nada útil que anclar
-      if (trayectoria.totalIteraciones === 0) return;
-
-      const output = {
-        hookSpecificOutput: {
-          hookEventName: 'UserPromptSubmit',
-          additionalContext: construirBloque(activa, trayectoria),
-        },
-      };
-      // Marcar el throttle SOLO tras un write exitoso: si stdout falla
-      // (broken pipe, harness cerró el canal), no registrar la inyección
-      // para que el próximo prompt reintente en vez de saltarse 4 min con
-      // un mensaje que nunca llegó. Best-effort: el hook nunca bloquea.
-      process.stdout.write(JSON.stringify(output), (err) => {
-        if (!err) {
-          try { registrarInyeccion(activa.dir); } catch { /* throttle best-effort */ }
-        }
-      });
-    } catch { /* nunca bloquea */ }
-  });
-}
-
-if (require.main === module) main();
-
-module.exports = { debeInyectar, registrarInyeccion, construirBloque, THROTTLE_MS, ARCHIVO_ESTADO };
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: contexto-iteracion.js
+ * Tipo: UserPromptSubmit (matcher vacío)
+ *
+ * Anti-context-rot para loops iterativos: cuando hay una corrida activa en
+ * .planning/loops/ (autoresearch, nemesis --remediar, verificar
+ * --until-converge, debate adversarial), inyecta al contexto un bloque
+ * compacto con el estado del loop — iteración actual, últimas 3 filas del
+ * TSV y la recomendación de trayectoria (continuar / detener por plateau /
+ * cambiar estrategia).
+ *
+ * En sesiones largas el modelo pierde de vista en qué iteración va y si la
+ * métrica sigue mejorando; este hook re-ancla ese estado sin que el agente
+ * tenga que releer archivos. Patrón adoptado del análisis de autoresearch
+ * v2.1 (hook iteration-context), adaptado a SWL: estado en el directorio de
+ * la corrida (no /tmp) y throttle por tiempo (no por conteo de prompts).
+ *
+ * Throttle: máximo 1 inyección cada 4 minutos por corrida (estado en
+ * .inject-state.json dentro del directorio de la corrida — se limpia solo
+ * con la corrida). 4 min < TTL del prompt cache (5 min): la inyección no
+ * coincide dos veces dentro de la misma ventana de cache.
+ *
+ * Zero-deps (solo hooks/lib/loop-telemetry). Nunca bloquea.
+ * Opt-out: SWL_CONTEXTO_ITERACION=0
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const { atomicWriteJSON } = require('./lib/atomic-write');
+const { corridaActiva, analizarTrayectoria } = require('./lib/loop-telemetry');
+
+/** Intervalo mínimo entre inyecciones para la misma corrida (4 minutos). */
+const THROTTLE_MS = 4 * 60 * 1000;
+
+const ARCHIVO_ESTADO = '.inject-state.json';
+
+/**
+ * Decide si toca inyectar según el estado de throttle de la corrida.
+ * @param {string} dirCorrida - Directorio de la corrida activa.
+ * @param {number} [ahora=Date.now()]
+ * @returns {boolean}
+ */
+function debeInyectar(dirCorrida, ahora = Date.now()) {
+  try {
+    const estado = JSON.parse(
+      fs.readFileSync(path.join(dirCorrida, ARCHIVO_ESTADO), 'utf8')
+    );
+    return ahora - (estado.ultimaInyeccion || 0) > THROTTLE_MS;
+  } catch {
+    return true; // sin estado = primera inyección
+  }
+}
+
+/** Registra la inyección para el throttle. Best-effort, escritura atómica. */
+function registrarInyeccion(dirCorrida, ahora = Date.now()) {
+  try {
+    atomicWriteJSON(
+      path.join(dirCorrida, ARCHIVO_ESTADO),
+      { ultimaInyeccion: ahora }
+    );
+  } catch { /* silencioso */ }
+}
+
+/**
+ * Construye el bloque de contexto a inyectar.
+ * @param {{dir: string, tipo: string, ultimasFilas: object[], totalFilas: number}} activa
+ * @param {object} trayectoria - Resultado de analizarTrayectoria.
+ * @returns {string}
+ */
+function construirBloque(activa, trayectoria) {
+  const lineas = [];
+  lineas.push(`🔁 Loop activo: \`${activa.tipo}\` (${path.basename(activa.dir)})`);
+  lineas.push(
+    `Iteraciones: ${trayectoria.totalIteraciones} | keep: ${trayectoria.keeps} | ` +
+    `revert: ${trayectoria.reverts} | métrica: ${trayectoria.metricaInicial} → ${trayectoria.metricaFinal}`
+  );
+
+  if (activa.ultimasFilas.length > 0) {
+    lineas.push('Últimas iteraciones:');
+    for (const fila of activa.ultimasFilas) {
+      const desc = (fila.descripcion || '').slice(0, 80);
+      lineas.push(`  ${fila.iteracion ?? '?'}. [${fila.estado || '?'}] métrica=${fila.metrica ?? '?'} — ${desc}`);
+    }
+  }
+
+  if (trayectoria.plateau) {
+    lineas.push(
+      '⚠️ PLATEAU detectado: las últimas iteraciones no mejoran la métrica. ' +
+      'Considera cerrar el loop y reportar el mejor estado alcanzado en lugar de seguir iterando.'
+    );
+  } else {
+    lineas.push(`Recomendación de trayectoria: ${trayectoria.recomendacion}.`);
+  }
+  lineas.push(`Registro completo: ${path.join(activa.dir, 'iteraciones.tsv')}`);
+
+  return lineas.join('\n');
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint
+// ---------------------------------------------------------------------------
+
+function main() {
+  let inputRaw = '';
+  process.stdin.on('data', (c) => { inputRaw += c; });
+
+  process.stdin.on('end', () => {
+    try {
+      if (process.env.SWL_CONTEXTO_ITERACION === '0') return;
+
+      const activa = corridaActiva(process.cwd(), { maxEdadMin: 30 });
+      if (!activa) return;
+      if (!debeInyectar(activa.dir)) return;
+
+      const trayectoria = analizarTrayectoria(activa.dir);
+      // Sin iteraciones más allá del baseline no hay nada útil que anclar
+      if (trayectoria.totalIteraciones === 0) return;
+
+      const output = {
+        hookSpecificOutput: {
+          hookEventName: 'UserPromptSubmit',
+          additionalContext: construirBloque(activa, trayectoria),
+        },
+      };
+      // Marcar el throttle SOLO tras un write exitoso: si stdout falla
+      // (broken pipe, harness cerró el canal), no registrar la inyección
+      // para que el próximo prompt reintente en vez de saltarse 4 min con
+      // un mensaje que nunca llegó. Best-effort: el hook nunca bloquea.
+      process.stdout.write(JSON.stringify(output), (err) => {
+        if (!err) {
+          try { registrarInyeccion(activa.dir); } catch { /* throttle best-effort */ }
+        }
+      });
+    } catch { /* nunca bloquea */ }
+  });
+}
+
+if (require.main === module) main();
+
+module.exports = { debeInyectar, registrarInyeccion, construirBloque, THROTTLE_MS, ARCHIVO_ESTADO };

package/hooks/guardrail-modelo.js

@@ -107,7 +107,7 @@ function razonTripwire(texto, trivialLen, tareaLigera) {
  */
 function modeloSugerido(modeloActual) {
   const m = (modeloActual || '').toLowerCase();
-  if (m.includes('opus'))   return 'claude-sonnet-4-6';
+  if (m.includes('opus'))   return 'claude-sonnet-5';
   if (m.includes('sonnet')) return 'claude-haiku-4-5-20251001';
   // haiku o inherit — no hay degradación posible
   return modeloActual || 'claude-haiku-4-5-20251001';

package/hooks/lib/agent-routing.js

@@ -1,107 +1,107 @@
-'use strict';
-
-/**
- * agent-routing.js — Helper para inferir fase y dominio del routing.
- *
- * Lee el frontmatter del agente (agentes/<nombre>.md) y extrae los campos
- * `fase` y `dominio` introducidos en v1.1.0 (ADR 0012). El orquestador no
- * registra explícitamente "qué fase/dominio motivó la elección" — pero
- * cuando elige un agente, podemos asumir que lo eligió porque su fase y
- * dominio matcheaban. Por lo tanto, leer el frontmatter del agente
- * efectivamente invocado nos da la celda fase×dominio del routing.
- *
- * Esto es proxy de precisión, no precisión absoluta:
- *   - Tasa de éxito por celda (fase, dominio) sirve como indicador de
- *     que el routing está enviando trabajo correctamente al agente
- *     adecuado.
- *   - Una celda con tasa de éxito baja sugiere routing impreciso (el
- *     agente recibe trabajo que no le compete) o agente sub-óptimo.
- *
- * Cache simple en memoria del proceso para evitar I/O repetida (cada
- * invocación de hook es proceso fresco, así que el cache no persiste,
- * pero protege dentro de la misma invocación).
- *
- * @module hooks/lib/agent-routing
- */
-
-const fs   = require('fs');
-const path = require('path');
-
-const _cache = Object.create(null);
-
-/**
- * Resuelve la ruta del archivo de agente. Acepta tanto el repo madre como
- * proyectos consumidores (donde los agentes pueden estar en otras rutas).
- *
- * @param {string} agentName - p.ej. "backend-python-swl"
- * @param {string} [cwd]     - Directorio de proyecto (default process.cwd())
- * @returns {string|null}    - Ruta absoluta o null si no existe
- */
-function resolveAgentPath(agentName, cwd) {
-  const baseDir = cwd || process.cwd();
-  const candidates = [
-    path.join(baseDir, 'agentes', `${agentName}.md`),
-    path.join(baseDir, '.claude', 'agents', `${agentName}.md`),
-  ];
-  for (const c of candidates) {
-    try { if (fs.statSync(c).isFile()) return c; } catch { /* siguiente */ }
-  }
-  return null;
-}
-
-/**
- * Extrae fase y dominio del frontmatter de un agente.
- *
- * @param {string} agentName - Nombre del agente sin extensión
- * @param {string} [cwd]
- * @returns {{ fase: string|null, dominio: string|null, source: string }}
- *   - source: 'frontmatter' | 'cache' | 'unknown'
- */
-function getRouting(agentName, cwd) {
-  if (!agentName) return { fase: null, dominio: null, source: 'unknown' };
-  if (_cache[agentName]) {
-    return { ..._cache[agentName], source: 'cache' };
-  }
-
-  const agentPath = resolveAgentPath(agentName, cwd);
-  if (!agentPath) {
-    const result = { fase: null, dominio: null, source: 'unknown' };
-    _cache[agentName] = { fase: null, dominio: null };
-    return result;
-  }
-
-  let raw;
-  try {
-    raw = fs.readFileSync(agentPath, 'utf8');
-  } catch {
-    return { fase: null, dominio: null, source: 'unknown' };
-  }
-
-  const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  if (!fmMatch) {
-    _cache[agentName] = { fase: null, dominio: null };
-    return { fase: null, dominio: null, source: 'unknown' };
-  }
-  const fm = fmMatch[1];
-
-  // Parser minimalista — solo busca las dos líneas que necesitamos.
-  // Evitamos depender de un parser YAML completo (zero-deps).
-  const faseMatch    = fm.match(/^fase:\s*(\S+)/m);
-  const dominioMatch = fm.match(/^dominio:\s*(\S+)/m);
-
-  const result = {
-    fase:    faseMatch    ? faseMatch[1].trim()    : null,
-    dominio: dominioMatch ? dominioMatch[1].trim() : null,
-  };
-  _cache[agentName] = result;
-  return { ...result, source: 'frontmatter' };
-}
-
-/**
- * Limpia el cache (para tests o tras modificar agentes).
- */
-function clearCache() {
-  for (const k of Object.keys(_cache)) delete _cache[k];
-}
-
-module.exports = { getRouting, resolveAgentPath, clearCache };
+'use strict';
+
+/**
+ * agent-routing.js — Helper para inferir fase y dominio del routing.
+ *
+ * Lee el frontmatter del agente (agentes/<nombre>.md) y extrae los campos
+ * `fase` y `dominio` introducidos en v1.1.0 (ADR 0012). El orquestador no
+ * registra explícitamente "qué fase/dominio motivó la elección" — pero
+ * cuando elige un agente, podemos asumir que lo eligió porque su fase y
+ * dominio matcheaban. Por lo tanto, leer el frontmatter del agente
+ * efectivamente invocado nos da la celda fase×dominio del routing.
+ *
+ * Esto es proxy de precisión, no precisión absoluta:
+ *   - Tasa de éxito por celda (fase, dominio) sirve como indicador de
+ *     que el routing está enviando trabajo correctamente al agente
+ *     adecuado.
+ *   - Una celda con tasa de éxito baja sugiere routing impreciso (el
+ *     agente recibe trabajo que no le compete) o agente sub-óptimo.
+ *
+ * Cache simple en memoria del proceso para evitar I/O repetida (cada
+ * invocación de hook es proceso fresco, así que el cache no persiste,
+ * pero protege dentro de la misma invocación).
+ *
+ * @module hooks/lib/agent-routing
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+const _cache = Object.create(null);
+
+/**
+ * Resuelve la ruta del archivo de agente. Acepta tanto el repo madre como
+ * proyectos consumidores (donde los agentes pueden estar en otras rutas).
+ *
+ * @param {string} agentName - p.ej. "backend-python-swl"
+ * @param {string} [cwd]     - Directorio de proyecto (default process.cwd())
+ * @returns {string|null}    - Ruta absoluta o null si no existe
+ */
+function resolveAgentPath(agentName, cwd) {
+  const baseDir = cwd || process.cwd();
+  const candidates = [
+    path.join(baseDir, 'agentes', `${agentName}.md`),
+    path.join(baseDir, '.claude', 'agents', `${agentName}.md`),
+  ];
+  for (const c of candidates) {
+    try { if (fs.statSync(c).isFile()) return c; } catch { /* siguiente */ }
+  }
+  return null;
+}
+
+/**
+ * Extrae fase y dominio del frontmatter de un agente.
+ *
+ * @param {string} agentName - Nombre del agente sin extensión
+ * @param {string} [cwd]
+ * @returns {{ fase: string|null, dominio: string|null, source: string }}
+ *   - source: 'frontmatter' | 'cache' | 'unknown'
+ */
+function getRouting(agentName, cwd) {
+  if (!agentName) return { fase: null, dominio: null, source: 'unknown' };
+  if (_cache[agentName]) {
+    return { ..._cache[agentName], source: 'cache' };
+  }
+
+  const agentPath = resolveAgentPath(agentName, cwd);
+  if (!agentPath) {
+    const result = { fase: null, dominio: null, source: 'unknown' };
+    _cache[agentName] = { fase: null, dominio: null };
+    return result;
+  }
+
+  let raw;
+  try {
+    raw = fs.readFileSync(agentPath, 'utf8');
+  } catch {
+    return { fase: null, dominio: null, source: 'unknown' };
+  }
+
+  const fmMatch = raw.match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  if (!fmMatch) {
+    _cache[agentName] = { fase: null, dominio: null };
+    return { fase: null, dominio: null, source: 'unknown' };
+  }
+  const fm = fmMatch[1];
+
+  // Parser minimalista — solo busca las dos líneas que necesitamos.
+  // Evitamos depender de un parser YAML completo (zero-deps).
+  const faseMatch    = fm.match(/^fase:\s*(\S+)/m);
+  const dominioMatch = fm.match(/^dominio:\s*(\S+)/m);
+
+  const result = {
+    fase:    faseMatch    ? faseMatch[1].trim()    : null,
+    dominio: dominioMatch ? dominioMatch[1].trim() : null,
+  };
+  _cache[agentName] = result;
+  return { ...result, source: 'frontmatter' };
+}
+
+/**
+ * Limpia el cache (para tests o tras modificar agentes).
+ */
+function clearCache() {
+  for (const k of Object.keys(_cache)) delete _cache[k];
+}
+
+module.exports = { getRouting, resolveAgentPath, clearCache };