@saulwade/swl-ses 1.0.0

package/hooks/actualizar-perfil-usuario.js

@@ -0,0 +1,364 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: actualizar-perfil-usuario.js
+ * Tipo: Stop (async: true — fire-and-forget)
+ * Registrado en: Stop (matcher vacío)
+ *
+ * Detecta señales en la sesión que justifican actualizar el modelo
+ * persistente del usuario (instintos/perfil-usuario.yaml).
+ *
+ * No modifica el perfil directamente — solo acumula señales en un
+ * "dirty-bit" (.planning/perfil-usuario/dirty.json) y, cuando el umbral
+ * se cruza, emite un nudge por stderr sugiriendo invocar el agente
+ * perfilador-usuario-swl.
+ *
+ * Señales detectadas (en input stdin con la transcripción de la sesión):
+ *   1. Correcciones del usuario: "no así", "mejor", "en vez de",
+ *      "en lugar de", "evita", "nunca", "siempre quiero", "prefiero".
+ *   2. Preferencias explícitas: "me gusta", "quiero que", "recuerda que",
+ *      "a partir de ahora".
+ *   3. Aprendizajes nuevos en .planning/APRENDIZAJES.md desde la última corrida.
+ *   4. Instintos con evidence_count >= 3 en instintos/proyecto.yaml.
+ *
+ * Umbral por defecto: 3 señales acumuladas → nudge.
+ *
+ * El hook nunca bloquea (siempre exit 0). Zero-dependencies.
+ */
+
+const fs   = require('fs');
+const path = require('path');
+
+let atomicWriteJSON;
+try {
+  ({ atomicWriteJSON } = require('./lib/atomic-write'));
+} catch {
+  // Fallback sin atomic-write si la librería no está (ej. en test aislado)
+  atomicWriteJSON = (p, obj) => fs.writeFileSync(p, JSON.stringify(obj, null, 2), 'utf8');
+}
+
+// Scanner de prompt injection — patrón adoptado de Hermes memory_tool.py.
+// Si la librería no está disponible (test aislado), fallback permisivo.
+let scanInjection;
+try {
+  ({ scan: scanInjection } = require('./lib/prompt-injection-scanner'));
+} catch {
+  scanInjection = () => ({ safe: true, threats: [], criticalCount: 0, highCount: 0 });
+}
+
+// Nudge tracker — registra cada nudge para medir tasa de acción.
+let nudgeTracker;
+try {
+  nudgeTracker = require('./lib/nudge-tracker');
+} catch {
+  nudgeTracker = null;
+}
+
+// ---------------------------------------------------------------------------
+// Configuración
+// ---------------------------------------------------------------------------
+
+const UMBRAL_NUDGE = parseInt(process.env.SWL_PERFIL_UMBRAL || '3', 10);
+const DIR_PERFIL   = path.join(process.cwd(), '.planning', 'perfil-usuario');
+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');
+
+// Keywords de corrección (señal fuerte: el usuario está corrigiendo)
+const KEYWORDS_CORRECCION = [
+  'no así', 'no asi', 'mejor', 'en vez de', 'en lugar de',
+  'evita', 'evites', 'no uses', 'nunca uses', 'nunca hagas',
+  'siempre quiero', 'siempre usa', 'prefiero', 'prefiere',
+  'no me gusta', 'deja de',
+];
+
+// Keywords de preferencia explícita (señal media)
+const KEYWORDS_PREFERENCIA = [
+  'me gusta', 'quiero que', 'recuerda que', 'a partir de ahora',
+  'de ahora en adelante', 'ten en cuenta',
+];
+
+// ---------------------------------------------------------------------------
+// Utilidades
+// ---------------------------------------------------------------------------
+
+function ensureDir(dir) {
+  try { fs.mkdirSync(dir, { recursive: true }); } catch { /* ignore */ }
+}
+
+function leerDirty() {
+  try {
+    const raw = fs.readFileSync(DIRTY_PATH, 'utf8');
+    return JSON.parse(raw);
+  } catch {
+    // Primera corrida: inicializar snapshot al estado actual para no
+    // generar falsos "nuevos" por el histórico preexistente.
+    return {
+      version: '1.0',
+      creado: new Date().toISOString(),
+      senales: [],
+      ultima_nudge: null,
+      snapshot: {
+        aprendizajes_headers: contarAprendizajesNuevos(0),
+        instintos_maduros: contarInstintosMaduros(),
+      },
+      primera_corrida: true,
+    };
+  }
+}
+
+function escribirDirty(estado) {
+  ensureDir(DIR_PERFIL);
+  atomicWriteJSON(DIRTY_PATH, estado);
+}
+
+function contarLineasArchivo(p) {
+  try {
+    return fs.readFileSync(p, 'utf8').split(/\r?\n/).length;
+  } catch {
+    return 0;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Detectores de señales
+// ---------------------------------------------------------------------------
+
+/**
+ * Busca keywords de corrección/preferencia en el texto.
+ * @returns {Array<{tipo:string, keyword:string, snippet:string}>}
+ */
+function detectarKeywords(texto) {
+  if (!texto || typeof texto !== 'string') return [];
+  const textoLow = texto.toLowerCase();
+  const señales = [];
+
+  for (const kw of KEYWORDS_CORRECCION) {
+    const idx = textoLow.indexOf(kw);
+    if (idx !== -1) {
+      señales.push({
+        tipo: 'correccion',
+        keyword: kw,
+        snippet: texto.slice(Math.max(0, idx - 20), idx + kw.length + 60).trim(),
+      });
+    }
+  }
+  for (const kw of KEYWORDS_PREFERENCIA) {
+    const idx = textoLow.indexOf(kw);
+    if (idx !== -1) {
+      señales.push({
+        tipo: 'preferencia',
+        keyword: kw,
+        snippet: texto.slice(Math.max(0, idx - 20), idx + kw.length + 60).trim(),
+      });
+    }
+  }
+
+  return señales;
+}
+
+/**
+ * Cuenta entradas en APRENDIZAJES.md desde una línea de referencia.
+ * @returns {number} cantidad de entradas nuevas
+ */
+function contarAprendizajesNuevos(lineaReferencia) {
+  try {
+    const contenido = fs.readFileSync(APRENDIZAJES_PATH, 'utf8');
+    const lineas = contenido.split(/\r?\n/);
+    const headers = lineas.filter(l => /^##\s+\[\d{4}-\d{2}-\d{2}\]/.test(l));
+    const headersAntes = Math.max(0, lineaReferencia);
+    return Math.max(0, headers.length - headersAntes);
+  } catch {
+    return 0;
+  }
+}
+
+/**
+ * Cuenta instintos con evidence_count >= 3 en instintos/proyecto.yaml.
+ * @returns {number}
+ */
+function contarInstintosMaduros() {
+  try {
+    const contenido = fs.readFileSync(INSTINTOS_PATH, 'utf8');
+    const matches = contenido.match(/evidence_count:\s*([3-9]|\d{2,})/g);
+    return matches ? matches.length : 0;
+  } catch {
+    return 0;
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Extracción del texto del usuario desde stdin del hook
+// ---------------------------------------------------------------------------
+
+/**
+ * Extrae los prompts del usuario de la transcripción que Claude Code pasa
+ * al hook Stop. El input viene como JSON con un array de mensajes.
+ *
+ * @param {string} inputRaw
+ * @returns {string} concatenación de prompts del usuario
+ */
+function extraerPromptsUsuario(inputRaw) {
+  if (!inputRaw) return '';
+  try {
+    const data = JSON.parse(inputRaw);
+    // Estructuras comunes: { messages: [...] } o { transcript: [...] }
+    const mensajes = data.messages || data.transcript || data.conversation || [];
+    if (!Array.isArray(mensajes)) return '';
+
+    return mensajes
+      .filter(m => m && (m.role === 'user' || m.type === 'user'))
+      .map(m => {
+        if (typeof m.content === 'string') return m.content;
+        if (Array.isArray(m.content)) {
+          return m.content
+            .filter(c => c && c.type === 'text' && typeof c.text === 'string')
+            .map(c => c.text)
+            .join('\n');
+        }
+        return '';
+      })
+      .join('\n\n');
+  } catch {
+    return '';
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Entrypoint
+// ---------------------------------------------------------------------------
+
+let inputRaw = '';
+process.stdin.on('data', chunk => { inputRaw += chunk; });
+
+process.stdin.on('end', () => {
+  try {
+    const textoUsuario = extraerPromptsUsuario(inputRaw);
+
+    const estado = leerDirty();
+    const totalPrevio = estado.senales.length;
+
+    // 1. Señales desde el texto del usuario, con escaneo de prompt injection
+    //    sobre cada snippet antes de persistir. Patrón adoptado de
+    //    Hermes memory_tool.py: el contenido que entra a memoria persistente
+    //    debe escanearse por inyección — de lo contrario un atacante con
+    //    acceso al prompt puede inyectar instrucciones que luego se recargan
+    //    cada sesión.
+    const señalesKw = detectarKeywords(textoUsuario)
+      .map(s => {
+        const r = scanInjection(s.snippet, 'perfil-usuario/dirty.json');
+        return { ...s, _scan: r };
+      })
+      .filter(s => {
+        // Descartar snippets con amenazas CRÍTICAS (prompt injection directa)
+        if (s._scan.criticalCount > 0) {
+          process.stderr.write(
+            `[perfil-usuario] señal descartada por injection crítica (${s._scan.threats[0]?.type}): keyword="${s.keyword}"\n`
+          );
+          return false;
+        }
+        return true;
+      })
+      .map(s => {
+        // Conservar snippet pero marcar si hubo patrones high (no críticos)
+        const out = { tipo: s.tipo, keyword: s.keyword, snippet: s.snippet };
+        if (s._scan.highCount > 0) {
+          out.warnings = s._scan.threats
+            .filter(t => t.severity === 'high')
+            .map(t => t.type);
+        }
+        return out;
+      });
+
+    // 2. Aprendizajes nuevos (delta desde el último snapshot)
+    //    En la primera corrida NO contamos histórico como "nuevo".
+    const snapshot = estado.snapshot || { aprendizajes_headers: 0, instintos_maduros: 0 };
+    const instintosMadurosActual = contarInstintosMaduros();
+    const aprendizajesNuevos = estado.primera_corrida
+      ? 0
+      : contarAprendizajesNuevos(snapshot.aprendizajes_headers);
+    const instintosNuevos = estado.primera_corrida
+      ? 0
+      : Math.max(0, instintosMadurosActual - snapshot.instintos_maduros);
+
+    delete estado.primera_corrida;
+
+    // 3. Agregar al dirty-bit
+    const ahora = new Date().toISOString();
+    const nuevas = [
+      ...señalesKw.map(s => ({ ...s, ts: ahora })),
+      ...(aprendizajesNuevos > 0
+        ? [{ tipo: 'aprendizaje-nuevo', count: aprendizajesNuevos, ts: ahora }]
+        : []),
+      ...(instintosNuevos > 0
+        ? [{ tipo: 'instinto-maduro', count: instintosNuevos, ts: ahora }]
+        : []),
+    ];
+
+    if (nuevas.length === 0) {
+      // Nada que registrar — actualizar snapshot y salir
+      estado.snapshot = {
+        aprendizajes_headers: contarAprendizajesNuevos(0),
+        instintos_maduros: instintosMadurosActual,
+      };
+      escribirDirty(estado);
+      return;
+    }
+
+    estado.senales.push(...nuevas);
+    estado.snapshot = {
+      aprendizajes_headers: contarAprendizajesNuevos(0),
+      instintos_maduros: instintosMadurosActual,
+    };
+
+    // 4. Verificar umbral para nudge
+    const total = estado.senales.length;
+    const cruzaUmbral = totalPrevio < UMBRAL_NUDGE && total >= UMBRAL_NUDGE;
+
+    // Evitar nudges repetidos: solo uno por día
+    let hacerNudge = cruzaUmbral;
+    if (hacerNudge && estado.ultima_nudge) {
+      const horas = (Date.now() - new Date(estado.ultima_nudge).getTime()) / 3600000;
+      if (horas < 24) hacerNudge = false;
+    }
+
+    if (hacerNudge) {
+      estado.ultima_nudge = ahora;
+
+      const perfilExiste = fs.existsSync(PERFIL_PATH);
+      const accion = perfilExiste
+        ? 'actualizar tu perfil de usuario'
+        : 'inicializar tu perfil de usuario';
+
+      const mensaje = [
+        '',
+        `[perfil-usuario] ${total} señales acumuladas sin consolidar.`,
+        `  Para ${accion}, invoca el agente:`,
+        `    "actualiza mi perfil de usuario"`,
+        `  (ejecuta el agente perfilador-usuario-swl)`,
+        '',
+      ].join('\n');
+
+      process.stderr.write(mensaje);
+
+      // Registrar en nudge-tracker para medir tasa de acción
+      if (nudgeTracker) {
+        try {
+          nudgeTracker.emit({
+            kind: 'perfil-usuario',
+            target: 'perfilador-usuario-swl',
+            message: mensaje.trim(),
+            source: 'hooks/actualizar-perfil-usuario.js',
+            data: { senalesAcumuladas: total },
+          });
+        } catch { /* silencioso */ }
+      }
+    }
+
+    escribirDirty(estado);
+  } catch {
+    // Nunca bloquear por error interno
+  }
+});

package/hooks/agente-lifecycle.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: agente-lifecycle.js
+ * Tipo: PostToolUse (Agent) + SubagentStop
+ *
+ * Emite eventos de ciclo de vida del agente al event-bus y actualiza
+ * el execution-state con el resultado de cada invocación de agente SWL.
+ * Registrado en SubagentStop para captura precisa de terminación de subagentes.
+ *
+ * Usa agent-backend.js para construir un SessionResult estandarizado
+ * desde el payload del hook PostToolUse y publicarlo al event-bus.
+ *
+ * Eventos emitidos:
+ *   agent:completed — agente terminó exitosamente
+ *   agent:failed    — agente terminó con error
+ *
+ * El hook nunca bloquea (siempre exit 0).
+ * Async: true — corre en background sin afectar la respuesta del modelo.
+ */
+
+const { desdePayloadHook, emitirCompletado } = require('./lib/agent-backend');
+const es = require('./lib/execution-state');
+
+const CWD = process.cwd();
+
+// ---------------------------------------------------------------------------
+// Entrypoint
+// ---------------------------------------------------------------------------
+
+let inputRaw = '';
+
+process.stdin.on('data', chunk => { inputRaw += chunk; });
+
+process.stdin.on('end', () => {
+  try {
+    const data     = JSON.parse(inputRaw);
+    const toolName = String(data.tool_name || data.tool?.name || '');
+
+    // Solo procesar invocaciones de agentes
+    if (toolName !== 'Agent') return;
+
+    const sessionResult = desdePayloadHook(data);
+    const runId         = String(data.session_id || 'default');
+
+    // 1. Publicar al event-bus
+    emitirCompletado(sessionResult, runId);
+
+    // 2. Actualizar execution-state si hay un agente activo
+    try {
+      const estado = es.leer(CWD);
+      if (estado?.agenteActual) {
+        const { agente, slice } = estado.agenteActual;
+        const resumen = {
+          status: sessionResult.status,
+          uso:    sessionResult.uso,
+          error:  sessionResult.error,
+        };
+        es.completarAgente(CWD, agente, slice, resumen, {
+          tokensEst: sessionResult.uso?.totalTokens || 0,
+        });
+      }
+    } catch (_) {
+      // execution-state puede no existir — no crítico
+    }
+
+  } catch (_) {
+    // Silencioso — nunca interrumpir la sesión por fallos del hook
+  }
+});

package/hooks/aiisms-detector.js

@@ -0,0 +1,173 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Hook: aiisms-detector.js
+ * Tipo: PostToolUse  (aplica a: Write, Edit, MultiEdit)
+ *
+ * Ejecuta el detector portable `habilidades/estilo-sin-ai-isms/scripts/detectar_aiisms.py`
+ * contra archivos .md recién modificados y emite un nudge a
+ * `.planning/evolucion/nudges.jsonl` si encuentra al menos un AI-ism
+ * de severidad P0.
+ *
+ * Opt-out: SWL_AIISMS_HOOK=0 desactiva completamente el hook.
+ * Opt-in obligatorio: requiere Python 3.10+ disponible. Si no está,
+ * el hook falla silenciosamente (nunca bloquea).
+ *
+ * Comportamiento:
+ *   - Nunca bloquea operaciones (exit code 0 siempre).
+ *   - Solo emite nudge cuando p0_count > 0 — ruido mínimo.
+ *   - Respeta auto-referencia: archivos dentro de `habilidades/estilo-sin-ai-isms/`
+ *     no se auditan (la skill habla SOBRE AI-isms, está llena de ejemplos).
+ *   - Respeta bloques de código, comillas y code spans (delegado al detector).
+ *
+ * Formato del nudge:
+ *   {
+ *     id: string,
+ *     kind: "aiisms-p0",
+ *     target: "documentador-swl",
+ *     source: "hooks/aiisms-detector.js",
+ *     message: "...",
+ *     data: { archivo, p0_count, p1_count, probabilidad },
+ *     ts: ISO
+ *   }
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { spawnSync, randomUUID } = require('child_process');
+const crypto = require('crypto');
+
+// Opt-out global del hook
+if (process.env.SWL_AIISMS_HOOK === '0') {
+  process.exit(0);
+}
+
+let hookInput = '';
+try {
+  hookInput = fs.readFileSync(0, 'utf-8');
+} catch (_) {
+  process.exit(0);
+}
+
+let evento;
+try {
+  evento = JSON.parse(hookInput);
+} catch (_) {
+  process.exit(0);
+}
+
+const toolName = evento?.tool_name;
+const toolInput = evento?.tool_input;
+
+if (!toolName || !['Write', 'Edit', 'MultiEdit'].includes(toolName)) {
+  process.exit(0);
+}
+
+// Extraer file_path según la herramienta
+const filePath = toolInput?.file_path;
+if (!filePath) {
+  process.exit(0);
+}
+
+// Filtros: solo .md y fuera de la skill de AI-isms (auto-referencia)
+if (!filePath.toLowerCase().endsWith('.md')) {
+  process.exit(0);
+}
+
+const pathNormalized = filePath.replace(/\\/g, '/');
+const RUTAS_EXCLUIDAS = [
+  'habilidades/estilo-sin-ai-isms/',
+  '.planning/',
+  'temp/',
+  'node_modules/',
+  'respositorios-git/',
+];
+if (RUTAS_EXCLUIDAS.some((excluida) => pathNormalized.includes(excluida))) {
+  process.exit(0);
+}
+
+// Archivo debe existir (tool Write/Edit debería haberlo creado/modificado)
+if (!fs.existsSync(filePath)) {
+  process.exit(0);
+}
+
+// Ruta del detector (zero-deps, stdlib Python)
+const CWD = process.cwd();
+const detector = path.join(CWD, 'habilidades', 'estilo-sin-ai-isms', 'scripts', 'detectar_aiisms.py');
+if (!fs.existsSync(detector)) {
+  process.exit(0);
+}
+
+// Ejecutar detector con salida JSON
+const pythonBin = process.env.PYTHON_BIN || 'python';
+let r;
+try {
+  r = spawnSync(pythonBin, [detector, '--archivo', filePath, '--json'], {
+    encoding: 'utf-8',
+    timeout: 15000,
+  });
+} catch (_) {
+  process.exit(0);
+}
+
+if (!r || r.error || r.status === 2) {
+  process.exit(0);
+}
+
+let reporte;
+try {
+  reporte = JSON.parse(r.stdout);
+} catch (_) {
+  process.exit(0);
+}
+
+// Solo emitir nudge si hay P0
+if (!reporte || !reporte.p0_count || reporte.p0_count === 0) {
+  process.exit(0);
+}
+
+// Construir nudge
+const topHallazgos = (reporte.hallazgos || [])
+  .filter((h) => h.severidad === 'P0')
+  .slice(0, 3)
+  .map((h) => `  - línea ${h.linea} [${h.categoria}]: "${h.texto.slice(0, 80)}"`)
+  .join('\n');
+
+const rutaRelativa = path.relative(CWD, filePath).replace(/\\/g, '/');
+
+const nudge = {
+  id: crypto.randomBytes(8).toString('hex'),
+  kind: 'aiisms-p0',
+  target: 'documentador-swl',
+  source: 'hooks/aiisms-detector.js',
+  message:
+    `[aiisms] ${reporte.p0_count} AI-ism(s) P0 detectado(s) en ${rutaRelativa}.\n` +
+    topHallazgos + '\n' +
+    `  Cargar Skill("estilo-sin-ai-isms") en modo rewrite para corregir.`,
+  data: {
+    archivo: rutaRelativa,
+    p0_count: reporte.p0_count,
+    p1_count: reporte.p1_count || 0,
+    p2_count: reporte.p2_count || 0,
+    probabilidad_generacion_llm: reporte.probabilidad_generacion_llm,
+  },
+  ts: new Date().toISOString(),
+  accionado: false,
+  accionado_ts: null,
+  accionado_por: null,
+};
+
+// Persistir a nudges.jsonl (JSONL append, no reescribir)
+try {
+  const nudgesPath = path.join(CWD, '.planning', 'evolucion', 'nudges.jsonl');
+  const nudgesDir = path.dirname(nudgesPath);
+  if (!fs.existsSync(nudgesDir)) {
+    fs.mkdirSync(nudgesDir, { recursive: true });
+  }
+  fs.appendFileSync(nudgesPath, JSON.stringify(nudge) + '\n', 'utf-8');
+} catch (_) {
+  // No fallar el hook por error de escritura
+}
+
+process.exit(0);