agentic-kdd 3.0.4 → 3.1.1

package/bin/akdd.js

@@ -55,6 +55,13 @@ const HELP = `
     akdd adr               Ingest ADRs from docs/adr/
     akdd knowledge         Ingest gotchas/conventions from docs/
 
+  Memory Governance (v3.2):
+    akdd cure              Run MemCurator — TTL, dedup, conflicts, scores
+    akdd cure report       Preview what curation would do (no changes)
+    akdd llms              Generate llms.txt + knowledge-graph.json
+    akdd benchmarks        LongMemEval + Token Reduction + Memory Quality scores
+    akdd causal-prune      Prune causal graph to prevent context collapse
+
   Metrics & Observability:
     akdd metrics           Project KPIs — success rate, rework, autonomy score
     akdd metrics trend     Show trend of last 10 cycles
@@ -220,6 +227,33 @@ switch (command) {
     break;
   }
 
+
+  // ── v3.2: MemCurator ───────────────────────────────────────────────────────
+  case 'cure': {
+    const sub = arg1 || 'run';
+    runModule('mem-curator.cjs', sub);
+    break;
+  }
+
+  // ── v3.2: llms.txt generator ───────────────────────────────────────────────
+  case 'llms': {
+    const sub = arg1 || 'all';
+    runModule('llms-generator.cjs', sub);
+    break;
+  }
+
+  // ── v3.2: Report benchmarks ────────────────────────────────────────────────
+  case 'benchmarks': {
+    runModule('metrics.cjs', 'benchmarks');
+    break;
+  }
+
+  // ── v3.2: Causal prune ─────────────────────────────────────────────────────
+  case 'causal-prune': {
+    runModule('causal-edges.cjs', 'prune');
+    break;
+  }
+
   // ── v3.0: Collaborative Mode (Legion) ────────────────────────────────
   case 'collab': {
     const sub = arg1 || 'status';

package/embeddings-v2.cjs

@@ -0,0 +1,320 @@
+#!/usr/bin/env node
+'use strict';
+
+/**
+ * Agentic KDD — Embeddings Engine v2.0
+ *
+ * Modelo DEFAULT: jina-embeddings-v2-base-code (Jina AI)
+ *   - 137M parámetros entrenados en CODE + texto natural (bimodal NL-PL)
+ *   - 768 dimensiones vs 384 de all-MiniLM
+ *   - Entiende relaciones lógicas de tipos, AST, control de flujo
+ *   - ~500MB instalado, 100% offline
+ *
+ * Fallback automático si jina no está: all-MiniLM-L6-v2 (384 dims, ~23MB)
+ *
+ * Gap cerrado: all-MiniLM-L6-v2 fue entrenado en NL natural, no en código.
+ * UniXcoder/jina mapean correctamente la semántica formal de lenguajes de programación.
+ *
+ * Uso:
+ *   node embeddings.cjs embed "function calculateTotal(price, qty)"
+ *   node embeddings.cjs status
+ *   node embeddings.cjs install-jina
+ *   node embeddings.cjs install-mini   (fallback ligero)
+ */
+
+const path = require('path');
+const fs   = require('fs');
+const { execSync } = require('child_process');
+
+// ─── MODELOS ──────────────────────────────────────────────────────────────────
+
+const MODELS = {
+  // Modelo primario: bimodal NL-PL, específico para código
+  JINA_CODE: {
+    id:   'jinaai/jina-embeddings-v2-base-code',
+    name: 'jina-embeddings-v2-base-code',
+    dims: 768,
+    size: '~500MB',
+    type: 'bimodal_nlpl',
+    description: 'Entrenado en código + texto. Entiende relaciones de tipos, AST, control de flujo.',
+  },
+  // Fallback: modelo NL general, ligero
+  MINI_LM: {
+    id:   'Xenova/all-MiniLM-L6-v2',
+    name: 'all-MiniLM-L6-v2',
+    dims: 384,
+    size: '~23MB',
+    type: 'natural_language',
+    description: 'Modelo NL general. Fallback cuando jina no está instalado.',
+  },
+};
+
+// ─── ESTADO INTERNO ───────────────────────────────────────────────────────────
+
+let _pipeline = null;
+let _activeModel = null;
+let _available = null;
+
+// ─── DETECCIÓN DE MODELO DISPONIBLE ──────────────────────────────────────────
+
+function detectAvailableModel(projectRoot) {
+  if (_available !== null) return _available;
+
+  // 1. Verificar si jina está en cache local del proyecto
+  const localCache = path.join(projectRoot || process.cwd(), '.agentic', '.model_cache');
+  if (fs.existsSync(localCache)) {
+    const jinaDir = path.join(localCache, 'models--jinaai--jina-embeddings-v2-base-code');
+    if (fs.existsSync(jinaDir)) {
+      _available = 'jina';
+      return 'jina';
+    }
+  }
+
+  // 2. Verificar cache global de HuggingFace
+  const hfCache = path.join(require('os').homedir(), '.cache', 'huggingface', 'hub');
+  if (fs.existsSync(hfCache)) {
+    const jinaGlobal = path.join(hfCache, 'models--jinaai--jina-embeddings-v2-base-code');
+    if (fs.existsSync(jinaGlobal)) {
+      _available = 'jina';
+      return 'jina';
+    }
+  }
+
+  // 3. Verificar si @xenova/transformers está instalado
+  try {
+    require.resolve('@xenova/transformers');
+    // MiniLM siempre descargable si transformers está
+    _available = 'mini';
+    return 'mini';
+  } catch {}
+
+  _available = false;
+  return false;
+}
+
+// ─── CARGAR PIPELINE ─────────────────────────────────────────────────────────
+
+async function getPipeline(projectRoot) {
+  if (_pipeline) return { pipeline: _pipeline, model: _activeModel };
+
+  const available = detectAvailableModel(projectRoot || process.cwd());
+
+  if (!available) {
+    return { pipeline: null, model: null };
+  }
+
+  try {
+    process.env.TRANSFORMERS_VERBOSITY = 'error';
+    const { pipeline, env } = require('@xenova/transformers');
+
+    // Usar cache local del proyecto si existe
+    const localCache = path.join(projectRoot || process.cwd(), '.agentic', '.model_cache');
+    if (fs.existsSync(localCache)) env.cacheDir = localCache;
+
+    const model = available === 'jina' ? MODELS.JINA_CODE : MODELS.MINI_LM;
+    _activeModel = model;
+
+    _pipeline = await pipeline('feature-extraction', model.id, { quantized: true });
+
+    return { pipeline: _pipeline, model };
+  } catch (e) {
+    _available = false;
+    return { pipeline: null, model: null };
+  }
+}
+
+// ─── GENERAR EMBEDDING ────────────────────────────────────────────────────────
+
+/**
+ * Genera embedding para código o texto.
+ * Retorna array de dims (768 con jina, 384 con mini) o null si no disponible.
+ */
+async function embed(text, projectRoot) {
+  const { pipeline: pipe } = await getPipeline(projectRoot);
+  if (!pipe) return null;
+  try {
+    const output = await pipe(text, { pooling: 'mean', normalize: true });
+    return Array.from(output.data);
+  } catch { return null; }
+}
+
+// ─── SIMILITUD COSENO ────────────────────────────────────────────────────────
+
+function cosineSim(a, b) {
+  if (!a || !b || a.length !== b.length) return 0;
+  let dot = 0, normA = 0, normB = 0;
+  for (let i = 0; i < a.length; i++) {
+    dot   += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+  const denom = Math.sqrt(normA) * Math.sqrt(normB);
+  return denom === 0 ? 0 : dot / denom;
+}
+
+// ─── BÚSQUEDA SEMÁNTICA ───────────────────────────────────────────────────────
+
+/**
+ * Búsqueda semántica sobre un array de items.
+ * @param {string} query - consulta en lenguaje natural o código
+ * @param {Array} items - [{id, texto, embedding}]
+ * @param {number} topK
+ */
+async function semanticSearch(query, items, topK = 10, projectRoot) {
+  const queryEmbed = await embed(query, projectRoot);
+  if (!queryEmbed) return items.slice(0, topK); // fallback sin embeddings
+
+  const scored = items
+    .filter(item => item.embedding && Array.isArray(item.embedding))
+    .map(item => ({
+      ...item,
+      score: cosineSim(queryEmbed, item.embedding),
+    }))
+    .sort((a, b) => b.score - a.score)
+    .slice(0, topK);
+
+  return scored;
+}
+
+// ─── STATUS ───────────────────────────────────────────────────────────────────
+
+async function getStatus(projectRoot) {
+  const available = detectAvailableModel(projectRoot || process.cwd());
+  const model = available === 'jina' ? MODELS.JINA_CODE : available === 'mini' ? MODELS.MINI_LM : null;
+
+  return {
+    available: !!available,
+    active_model: model?.name || 'none',
+    model_type: model?.type || 'none',
+    dims: model?.dims || 0,
+    size: model?.size || 'N/A',
+    description: model?.description || 'Sin modelo de embeddings instalado',
+    recommended: 'jina-embeddings-v2-base-code',
+    install_command: available === 'jina' ? 'Ya instalado ✅' : 'akdd jina-install',
+    gap_status: available === 'jina'
+      ? '✅ Modelo bimodal NL-PL activo — semántica de código precisa'
+      : available === 'mini'
+        ? '⚠️  Usando all-MiniLM-L6-v2 — no optimizado para código. Ejecutar: akdd jina-install'
+        : '❌ Sin embeddings — búsqueda semántica desactivada. Ejecutar: akdd embed-install',
+  };
+}
+
+// ─── INSTALACIÓN ─────────────────────────────────────────────────────────────
+
+/**
+ * Instalar jina-embeddings-v2-base-code (modelo primario recomendado).
+ * ~500MB. Se guarda en .agentic/.model_cache para uso offline.
+ */
+async function installJina(projectRoot) {
+  projectRoot = projectRoot || process.cwd();
+  console.log('\n[EMBEDDINGS] Instalando jina-embeddings-v2-base-code...');
+  console.log('[EMBEDDINGS] Tamaño: ~500MB. Puede tomar 5-10 minutos.');
+  console.log('[EMBEDDINGS] Modelo bimodal NL-PL — entrenado específicamente en código.\n');
+
+  // Verificar que @xenova/transformers está instalado
+  try {
+    require.resolve('@xenova/transformers');
+  } catch {
+    console.log('[EMBEDDINGS] Instalando @xenova/transformers primero...');
+    execSync('npm install @xenova/transformers --save-dev', {
+      stdio: 'inherit',
+      cwd: projectRoot,
+    });
+  }
+
+  // Descargar el modelo
+  try {
+    process.env.TRANSFORMERS_VERBOSITY = 'info';
+    const { pipeline, env } = require('@xenova/transformers');
+    const localCache = path.join(projectRoot, '.agentic', '.model_cache');
+    fs.mkdirSync(localCache, { recursive: true });
+    env.cacheDir = localCache;
+
+    console.log('[EMBEDDINGS] Descargando modelo...');
+    const pipe = await pipeline('feature-extraction', MODELS.JINA_CODE.id, { quantized: true });
+
+    // Test
+    const testEmbed = await pipe('function test() { return 1; }', { pooling: 'mean', normalize: true });
+    if (testEmbed && testEmbed.data.length > 0) {
+      console.log(`\n[EMBEDDINGS] ✅ jina-embeddings-v2-base-code instalado.`);
+      console.log(`[EMBEDDINGS] Dimensiones: ${testEmbed.data.length}`);
+      console.log(`[EMBEDDINGS] Búsqueda semántica de código ahora es precisa.\n`);
+      _available = 'jina';
+      _pipeline = pipe;
+    }
+  } catch (e) {
+    console.error('[EMBEDDINGS] Error instalando jina:', e.message);
+    console.log('[EMBEDDINGS] Alternativa: akdd embed-install (all-MiniLM-L6-v2, 23MB)\n');
+  }
+}
+
+/**
+ * Instalar all-MiniLM-L6-v2 (fallback ligero, ~23MB).
+ */
+async function installMini(projectRoot) {
+  projectRoot = projectRoot || process.cwd();
+  console.log('\n[EMBEDDINGS] Instalando all-MiniLM-L6-v2 (modelo ligero, 23MB)...');
+  console.log('[EMBEDDINGS] Nota: este modelo es para texto natural, no optimizado para código.');
+  console.log('[EMBEDDINGS] Para precisión máxima en código: akdd jina-install\n');
+
+  try {
+    require.resolve('@xenova/transformers');
+  } catch {
+    execSync('npm install @xenova/transformers --save-dev', { stdio: 'inherit', cwd: projectRoot });
+  }
+
+  try {
+    const { pipeline, env } = require('@xenova/transformers');
+    const localCache = path.join(projectRoot, '.agentic', '.model_cache');
+    fs.mkdirSync(localCache, { recursive: true });
+    env.cacheDir = localCache;
+
+    const pipe = await pipeline('feature-extraction', MODELS.MINI_LM.id, { quantized: true });
+    console.log('\n[EMBEDDINGS] ✅ all-MiniLM-L6-v2 instalado como fallback.\n');
+    _available = 'mini';
+    _pipeline = pipe;
+  } catch (e) {
+    console.error('[EMBEDDINGS] Error:', e.message);
+  }
+}
+
+// ─── CLI ──────────────────────────────────────────────────────────────────────
+
+if (require.main === module) {
+  const [,, cmd, ...args] = process.argv;
+  const projectRoot = process.cwd();
+
+  switch (cmd) {
+    case 'embed':
+      if (!args[0]) { console.error('Uso: embeddings.cjs embed "<texto>"'); break; }
+      embed(args.join(' '), projectRoot).then(v => {
+        if (!v) console.log('Sin embeddings disponibles. Ejecutar: akdd jina-install');
+        else console.log(`Vector [${v.length} dims]: [${v.slice(0,4).map(x=>x.toFixed(4)).join(', ')}...]`);
+      });
+      break;
+
+    case 'status':
+      getStatus(projectRoot).then(s => {
+        console.log('\n=== Embeddings Status ===');
+        console.log(`Modelo activo: ${s.active_model}`);
+        console.log(`Tipo:          ${s.model_type}`);
+        console.log(`Dimensiones:   ${s.dims}`);
+        console.log(`Gap:           ${s.gap_status}`);
+        console.log(`Instalar:      ${s.install_command}\n`);
+      });
+      break;
+
+    case 'install-jina':
+      installJina(projectRoot).catch(console.error);
+      break;
+
+    case 'install-mini':
+      installMini(projectRoot).catch(console.error);
+      break;
+
+    default:
+      console.log('Uso: embeddings.cjs [embed <text> | status | install-jina | install-mini]');
+  }
+}
+
+module.exports = { embed, cosineSim, semanticSearch, getStatus, installJina, installMini, detectAvailableModel, MODELS };

package/llms-generator.cjs

@@ -0,0 +1,425 @@
+/**
+ * Agentic KDD — llms.txt Generator v1.0
+ *
+ * Genera automáticamente:
+ *   .agentic/llms.txt       — mapa estructural mínimo para agentes externos
+ *   .agentic/llms-full.txt  — versión expandida con todas las reglas vigentes
+ *   .agentic/knowledge-graph.json — grafo causal serializado para Git versioning
+ *
+ * ¿Qué resuelve?
+ *   Gap: "Discoverability" — agentes externos no saben qué hay en Agentic KDD sin indexar todo
+ *   Solución: llms.txt es el estándar emergente (equiv a robots.txt pero para LLMs)
+ *
+ *   Gap: "Grafo descentralizado" — el reporte pide que el grafo viaje en el repo vía Git
+ *   Solución: knowledge-graph.json en .agentic/ → versión del grafo junto al código
+ *
+ *   Gap: "Progressive disclosure" — developer nuevo no sabe por dónde empezar
+ *   Solución: llms.txt actúa como mapa de onboarding estructurado
+ *
+ * Se ejecuta automáticamente en: akdd sync, akdd update
+ * También se puede correr manualmente: node llms-generator.cjs
+ *
+ * Uso:
+ *   node .agentic/grafo/llms-generator.cjs generate
+ *   node .agentic/grafo/llms-generator.cjs graph
+ *   node .agentic/grafo/llms-generator.cjs all
+ */
+
+'use strict';
+
+const path = require('path');
+const fs   = require('fs');
+
+// ─── DB HELPER ────────────────────────────────────────────────────────────────
+
+function openDB(projectRoot) {
+  const dbPath = path.join(projectRoot, '.agentic/memoria.db');
+  try { return new (require('better-sqlite3'))(dbPath); } catch {}
+  try { const { DatabaseSync } = require('node:sqlite'); return new DatabaseSync(dbPath); } catch {}
+  return null; // Si no hay DB, generar desde config.md
+}
+
+// ─── LEER CONFIG DEL PROYECTO ────────────────────────────────────────────────
+
+function readProjectConfig(projectRoot) {
+  const configPath = path.join(projectRoot, '.agentic', 'config.md');
+  if (!fs.existsSync(configPath)) return {};
+
+  const content = fs.readFileSync(configPath, 'utf8');
+  const config  = {};
+
+  // Extraer campos clave del config.md
+  const extractField = (key) => {
+    const match = content.match(new RegExp(`${key}:\\s*(.+)`));
+    return match ? match[1].trim() : null;
+  };
+
+  config.proyecto   = extractField('PROYECTO');
+  config.stack      = extractField('STACK');
+  config.descripcion= extractField('DESCRIPCIÓN') || extractField('DESCRIPCION');
+  config.modulos    = [];
+
+  // Extraer módulos listados
+  const modulosMatch = content.match(/MÓDULOS[^\n]*\n([\s\S]*?)(?=\n##|\n\*\*|$)/i);
+  if (modulosMatch) {
+    config.modulos = modulosMatch[1]
+      .split('\n')
+      .map(l => l.replace(/^[-*\s]+/, '').trim())
+      .filter(Boolean)
+      .slice(0, 20);
+  }
+
+  return config;
+}
+
+// ─── GENERAR llms.txt ─────────────────────────────────────────────────────────
+/**
+ * llms.txt: formato estándar emergente para que LLMs se orienten en un proyecto.
+ * Minimalista. Agentes externos lo leen antes de explorar el codebase.
+ */
+function generateLlmsTxt(projectRoot, db) {
+  const config = readProjectConfig(projectRoot);
+
+  const lines = [];
+  const now = new Date().toISOString().split('T')[0];
+
+  lines.push(`# ${config.proyecto || path.basename(projectRoot)}`);
+  lines.push('');
+  if (config.descripcion) {
+    lines.push(`> ${config.descripcion}`);
+    lines.push('');
+  }
+  lines.push(`> Agentic KDD v3.2 — Knowledge-Driven Development`);
+  lines.push(`> Generated: ${now}`);
+  lines.push('');
+
+  // Stack
+  if (config.stack) {
+    lines.push('## Stack');
+    lines.push('');
+    config.stack.split(/[,/]/).map(s => s.trim()).filter(Boolean).forEach(s => {
+      lines.push(`- ${s}`);
+    });
+    lines.push('');
+  }
+
+  // Módulos del proyecto
+  if (db) {
+    try {
+      const entities = db.prepare(`
+        SELECT nombre, tipo, descripcion, area
+        FROM entidades WHERE tipo IN ('modulo','archivo','api','tabla')
+        ORDER BY tipo, nombre LIMIT 30
+      `).all();
+
+      if (entities.length > 0) {
+        lines.push('## Architecture');
+        lines.push('');
+        const byType = {};
+        entities.forEach(e => {
+          if (!byType[e.tipo]) byType[e.tipo] = [];
+          byType[e.tipo].push(e);
+        });
+        Object.entries(byType).forEach(([tipo, ents]) => {
+          lines.push(`### ${tipo.charAt(0).toUpperCase() + tipo.slice(1)}s`);
+          ents.slice(0, 10).forEach(e => {
+            lines.push(`- **${e.nombre}**: ${e.descripcion || e.area || tipo}`);
+          });
+          lines.push('');
+        });
+      }
+    } catch {}
+  } else if (config.modulos?.length > 0) {
+    lines.push('## Modules');
+    lines.push('');
+    config.modulos.forEach(m => lines.push(`- ${m}`));
+    lines.push('');
+  }
+
+  // Reglas vigentes HIGH
+  if (db) {
+    try {
+      const rules = db.prepare(`
+        SELECT titulo, area, tipo
+        FROM nodos
+        WHERE confianza = 'ALTA'
+          AND estado = 'ACTIVO'
+          AND (vigencia_tipo = 'VIGENTE' OR vigencia_tipo IS NULL)
+        ORDER BY aplicado DESC LIMIT 15
+      `).all();
+
+      if (rules.length > 0) {
+        lines.push('## Key Rules (HIGH confidence)');
+        lines.push('');
+        rules.forEach(r => {
+          lines.push(`- [${r.tipo}] ${r.titulo} (${r.area || 'global'})`);
+        });
+        lines.push('');
+      }
+    } catch {}
+  }
+
+  // ADRs activos
+  if (db) {
+    try {
+      const adrs = db.prepare(`
+        SELECT titulo, decision, status FROM knowledge_docs
+        WHERE status = 'accepted' LIMIT 10
+      `).all();
+
+      if (adrs.length > 0) {
+        lines.push('## Architecture Decisions');
+        lines.push('');
+        adrs.forEach(a => {
+          lines.push(`- **${a.titulo}**: ${a.decision?.substring(0, 80) || ''}`);
+        });
+        lines.push('');
+      }
+    } catch {}
+  }
+
+  // Errores frecuentes (memoria causal)
+  if (db) {
+    try {
+      const errors = db.prepare(`
+        SELECT titulo FROM nodos
+        WHERE tipo = 'error'
+          AND confianza IN ('ALTA','MEDIA')
+          AND estado = 'ACTIVO'
+        ORDER BY aplicado DESC LIMIT 10
+      `).all();
+
+      if (errors.length > 0) {
+        lines.push('## Known Pitfalls');
+        lines.push('');
+        errors.forEach(e => lines.push(`- ${e.titulo}`));
+        lines.push('');
+      }
+    } catch {}
+  }
+
+  // Footer
+  lines.push('## Agentic KDD Tools');
+  lines.push('');
+  lines.push('This project uses Agentic KDD for persistent AI memory. Available MCP tools:');
+  lines.push('- `grafo_buscar` — hybrid search across 4 CoALA memory layers');
+  lines.push('- `ast_impact` — pre-change impact analysis');
+  lines.push('- `knowledge_query` — query ADRs and gotchas');
+  lines.push('- `verdad_vigente` — currently valid rules only');
+  lines.push('- `decision_trail` — decision observability');
+  lines.push('- `health_check` — full system diagnostic');
+  lines.push('');
+  lines.push('Run `akdd health` to verify system state before working.');
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+// ─── GENERAR llms-full.txt ────────────────────────────────────────────────────
+/**
+ * Versión expandida con TODO el conocimiento vigente del proyecto.
+ * Para agentes que necesitan contexto completo antes de empezar.
+ */
+function generateLlmsFullTxt(projectRoot, db) {
+  if (!db) return null;
+
+  const lines = [];
+  const minimal = generateLlmsTxt(projectRoot, db);
+  lines.push(minimal);
+
+  lines.push('---');
+  lines.push('## Full Knowledge Base');
+  lines.push('');
+
+  // Todos los patrones ALTA y MEDIA vigentes
+  try {
+    const patterns = db.prepare(`
+      SELECT titulo, contenido, tipo, area, aplicado, util
+      FROM nodos
+      WHERE estado = 'ACTIVO'
+        AND confianza IN ('ALTA', 'MEDIA')
+        AND (vigencia_tipo = 'VIGENTE' OR vigencia_tipo IS NULL)
+      ORDER BY confianza DESC, aplicado DESC
+      LIMIT 50
+    `).all();
+
+    if (patterns.length > 0) {
+      lines.push('### All Active Patterns');
+      lines.push('');
+      patterns.forEach(p => {
+        lines.push(`#### [${p.tipo}] ${p.titulo} (${p.area || 'global'})`);
+        if (p.contenido) lines.push(p.contenido.substring(0, 300));
+        lines.push(`*Applied: ${p.aplicado || 0}× | Useful: ${p.util || 0}×*`);
+        lines.push('');
+      });
+    }
+  } catch {}
+
+  // Causal edges activos
+  try {
+    const edges = db.prepare(`
+      SELECT desde_entidad, tipo, hacia_entidad, descripcion
+      FROM relaciones_semanticas
+      WHERE tipo IN ('caused_failure','was_fixed_by','tested_by','regressed_by')
+        AND (invalid_at IS NULL OR invalid_at = '')
+      ORDER BY valid_at DESC LIMIT 30
+    `).all();
+
+    if (edges.length > 0) {
+      lines.push('### Causal Memory');
+      lines.push('');
+      edges.forEach(e => {
+        lines.push(`- ${e.desde_entidad} --${e.tipo}--> ${e.hacia_entidad}`);
+        if (e.descripcion) lines.push(`  *${e.descripcion.substring(0, 100)}*`);
+      });
+      lines.push('');
+    }
+  } catch {}
+
+  return lines.join('\n');
+}
+
+// ─── GENERAR knowledge-graph.json ────────────────────────────────────────────
+/**
+ * Grafo causal serializado para Git versioning.
+ * Viaja con el repo → el equipo comparte el grafo sin infraestructura externa.
+ * Inspirado en Graphify y Understand Anything.
+ */
+function generateKnowledgeGraph(projectRoot, db) {
+  if (!db) return null;
+
+  const graph = {
+    version: '3.2',
+    generated: new Date().toISOString(),
+    project: path.basename(projectRoot),
+    nodes: [],
+    edges: [],
+    decisions: [],
+    stats: {},
+  };
+
+  // Nodos procedurales vigentes
+  try {
+    graph.nodes = db.prepare(`
+      SELECT id, tipo, titulo, area, confianza, aplicado, util,
+             decay_score, vigencia_tipo, fecha_creacion
+      FROM nodos
+      WHERE estado = 'ACTIVO'
+        AND (vigencia_tipo = 'VIGENTE' OR vigencia_tipo IS NULL)
+        AND confianza IN ('ALTA', 'MEDIA')
+      ORDER BY confianza DESC, aplicado DESC
+      LIMIT 200
+    `).all();
+  } catch {}
+
+  // Edges causales activos
+  try {
+    graph.edges = db.prepare(`
+      SELECT desde_entidad, tipo, hacia_entidad, descripcion, confidence, valid_at
+      FROM relaciones_semanticas
+      WHERE tipo IN ('caused_failure','was_fixed_by','tested_by','regressed_by','depends_on_decision')
+        AND (invalid_at IS NULL OR invalid_at = '')
+      ORDER BY valid_at DESC LIMIT 300
+    `).all();
+  } catch {}
+
+  // ADRs
+  try {
+    graph.decisions = db.prepare(`
+      SELECT doc_id, titulo, decision, status, afecta, fecha_indexado
+      FROM knowledge_docs
+      WHERE status = 'accepted'
+      LIMIT 50
+    `).all();
+  } catch {}
+
+  // Stats
+  graph.stats = {
+    total_nodes: graph.nodes.length,
+    total_edges: graph.edges.length,
+    total_decisions: graph.decisions.length,
+    high_confidence: graph.nodes.filter(n => n.confianza === 'ALTA').length,
+  };
+
+  return graph;
+}
+
+// ─── GENERAR TODO ─────────────────────────────────────────────────────────────
+
+function generateAll(projectRoot) {
+  projectRoot = projectRoot || process.cwd();
+  const db = openDB(projectRoot);
+
+  const results = { llms_txt: false, llms_full: false, knowledge_graph: false };
+
+  // 1. llms.txt
+  try {
+    const content = generateLlmsTxt(projectRoot, db);
+    fs.writeFileSync(path.join(projectRoot, '.agentic', 'llms.txt'), content);
+    results.llms_txt = true;
+    console.log('[LLMS] ✅ .agentic/llms.txt generado');
+  } catch (e) {
+    console.error('[LLMS] Error llms.txt:', e.message);
+  }
+
+  // 2. llms-full.txt
+  if (db) {
+    try {
+      const content = generateLlmsFullTxt(projectRoot, db);
+      if (content) {
+        fs.writeFileSync(path.join(projectRoot, '.agentic', 'llms-full.txt'), content);
+        results.llms_full = true;
+        console.log('[LLMS] ✅ .agentic/llms-full.txt generado');
+      }
+    } catch (e) {
+      console.error('[LLMS] Error llms-full.txt:', e.message);
+    }
+  }
+
+  // 3. knowledge-graph.json
+  if (db) {
+    try {
+      const graph = generateKnowledgeGraph(projectRoot, db);
+      if (graph) {
+        fs.writeFileSync(
+          path.join(projectRoot, '.agentic', 'knowledge-graph.json'),
+          JSON.stringify(graph, null, 2)
+        );
+        results.knowledge_graph = true;
+        console.log(`[LLMS] ✅ .agentic/knowledge-graph.json generado (${graph.stats.total_nodes} nodos, ${graph.stats.total_edges} edges)`);
+      }
+    } catch (e) {
+      console.error('[LLMS] Error knowledge-graph.json:', e.message);
+    }
+  }
+
+  return results;
+}
+
+// ─── CLI ──────────────────────────────────────────────────────────────────────
+
+if (require.main === module) {
+  const [,, cmd] = process.argv;
+  const projectRoot = process.cwd();
+
+  switch (cmd) {
+    case 'generate':
+      const db = openDB(projectRoot);
+      const content = generateLlmsTxt(projectRoot, db);
+      fs.writeFileSync(path.join(projectRoot, '.agentic', 'llms.txt'), content);
+      console.log('✅ .agentic/llms.txt generado');
+      break;
+    case 'graph':
+      const db2 = openDB(projectRoot);
+      if (!db2) { console.error('DB no disponible'); break; }
+      const graph = generateKnowledgeGraph(projectRoot, db2);
+      fs.writeFileSync(path.join(projectRoot, '.agentic', 'knowledge-graph.json'), JSON.stringify(graph, null, 2));
+      console.log(`✅ knowledge-graph.json: ${graph.stats.total_nodes} nodos, ${graph.stats.total_edges} edges`);
+      break;
+    case 'all':
+    default:
+      generateAll(projectRoot);
+  }
+}
+
+module.exports = { generateLlmsTxt, generateLlmsFullTxt, generateKnowledgeGraph, generateAll };

package/mem-curator.cjs

@@ -0,0 +1,584 @@
+/**
+ * Agentic KDD — MemCurator v1.0
+ *
+ * Agente de gobernanza autónoma de memoria. Cierra múltiples gaps del reporte:
+ *
+ *   ✅ TTL enforcement: episodios > 30 días → archivo/compresión
+ *   ✅ Deduplicación semántica: nodos similares > umbral → merge
+ *   ✅ Resolución de conflictos: reglas contradictorias → supersesión explícita
+ *   ✅ Scoring de relevancia ponderado: S(k) = cos_sim × exp(-λ×Δt) × log(1+n_accesos)
+ *   ✅ MemCurator independiente: desvinculado del generador de código (evita sesgo de autovalidación)
+ *   ✅ Prevención de ruido semántico: "envenenamiento por redundancia" controlado
+ *
+ * El curador corre automáticamente cada 10 ciclos (hookeado en grafo.cjs sync).
+ * También se puede correr manualmente: node mem-curator.cjs run
+ *
+ * Basado en:
+ *   - arXiv 2603.17787 "Governed Memory: A Production Architecture for Multi-Agent Workflows"
+ *   - Zep/Graphiti temporal graph (arXiv 2501.13956)
+ *   - Mem0 atomic fact extraction pattern
+ *
+ * Uso:
+ *   node .agentic/grafo/mem-curator.cjs run        — curation completa
+ *   node .agentic/grafo/mem-curator.cjs ttl        — solo TTL enforcement
+ *   node .agentic/grafo/mem-curator.cjs dedup      — solo deduplicación
+ *   node .agentic/grafo/mem-curator.cjs conflicts  — solo conflictos
+ *   node .agentic/grafo/mem-curator.cjs score      — recalcular scores de todos los nodos
+ *   node .agentic/grafo/mem-curator.cjs report     — reporte sin cambios
+ */
+
+'use strict';
+
+const path = require('path');
+const fs   = require('fs');
+
+// ─── CONSTANTES ───────────────────────────────────────────────────────────────
+
+const TTL_EPISODIC_DAYS    = 30;   // Episodios: retención máxima en caliente
+const TTL_WORKING_DAYS     = 7;    // Working memory: expira rápido
+const LAMBDA_DECAY         = 0.05; // Constante de decay temporal (λ)
+const DEDUP_THRESHOLD      = 0.92; // Similitud coseno > 92% → duplicado
+const CONFLICT_THRESHOLD   = 0.85; // Similitud alta + contenido contradictorio
+const MAX_SEMANTIC_NODES   = 1000; // Límite de nodos procedurales activos
+const MIN_UTILITY_RATIO    = 0.15; // util/aplicado < 15% → candidato a deprecar
+const CURATOR_LOG_PATH     = '.agentic/curator.log';
+
+// ─── DB HELPER ────────────────────────────────────────────────────────────────
+
+function openDB(projectRoot) {
+  const dbPath = path.join(projectRoot, '.agentic/memoria.db');
+  try { return new (require('better-sqlite3'))(dbPath); } catch {}
+  try { const { DatabaseSync } = require('node:sqlite'); return new DatabaseSync(dbPath); } catch {}
+  throw new Error('No SQLite driver disponible');
+}
+
+function log(projectRoot, msg) {
+  const logPath = path.join(projectRoot, CURATOR_LOG_PATH);
+  const entry = `[${new Date().toISOString()}] ${msg}\n`;
+  try { fs.appendFileSync(logPath, entry); } catch {}
+  console.log(`[CURATOR] ${msg}`);
+}
+
+// ─── SCORING DE RELEVANCIA PONDERADO ─────────────────────────────────────────
+/**
+ * Fórmula del reporte (arXiv 2603.17787):
+ * S(k) = cosine_sim(k, query) × exp(-λ × Δt_days) × log(1 + n_accesos)
+ *
+ * Para nodos sin query (relevancia absoluta):
+ * S(k) = confidence_weight × exp(-λ × Δt_days) × log(1 + n_accesos)
+ */
+function computeRelevanceScore(node, queryEmbedding, cosineFn) {
+  const now = Date.now();
+
+  // Δt en días desde última actualización
+  const lastUpdate = node.fecha_update || node.fecha_creacion || new Date().toISOString();
+  const deltaDays = (now - new Date(lastUpdate).getTime()) / (1000 * 60 * 60 * 24);
+
+  // Decay temporal exponencial
+  const decayFactor = Math.exp(-LAMBDA_DECAY * deltaDays);
+
+  // Frecuencia de uso
+  const usageScore = Math.log(1 + (node.aplicado || 0));
+
+  // Similitud semántica (si hay query embedding disponible)
+  let simScore = 1.0;
+  if (queryEmbedding && node.embedding && cosineFn) {
+    try {
+      const nodeEmbed = typeof node.embedding === 'string'
+        ? JSON.parse(node.embedding) : node.embedding;
+      simScore = cosineFn(queryEmbedding, nodeEmbed);
+    } catch {}
+  } else {
+    // Sin embedding: usar confianza como proxy de similitud
+    const confMap = { 'ALTA': 0.9, 'MEDIA': 0.6, 'BAJA': 0.3 };
+    simScore = confMap[node.confianza] || 0.5;
+  }
+
+  const score = simScore * decayFactor * (1 + usageScore * 0.1);
+
+  return {
+    node_id: node.id,
+    titulo: node.titulo,
+    score: Math.round(score * 1000) / 1000,
+    components: {
+      similarity: Math.round(simScore * 1000) / 1000,
+      decay: Math.round(decayFactor * 1000) / 1000,
+      usage: Math.round(usageScore * 1000) / 1000,
+      delta_days: Math.round(deltaDays),
+    },
+  };
+}
+
+// ─── TTL ENFORCEMENT ─────────────────────────────────────────────────────────
+/**
+ * Episodios > 30 días sin consolidar → comprimir en resumen + archivar.
+ * Working memory > 7 días → eliminar.
+ * Esto implementa la Capa Episódica del reporte.
+ */
+function enforceEpisodicTTL(db, projectRoot) {
+  const results = { compressed: 0, archived: 0, deleted: 0 };
+
+  // 1. Episodios > TTL_EPISODIC_DAYS días sin consolidar → comprimir
+  try {
+    const staleEpisodes = db.prepare(`
+      SELECT episodio_id, tipo, descripcion, resultado, fecha, modulo
+      FROM episodios
+      WHERE consolidado = 0
+        AND julianday('now') - julianday(fecha) > ?
+      ORDER BY fecha ASC
+      LIMIT 100
+    `).all(TTL_EPISODIC_DAYS);
+
+    if (staleEpisodes.length > 0) {
+      // Generar resumen comprimido por módulo
+      const byModule = {};
+      staleEpisodes.forEach(ep => {
+        const mod = ep.modulo || 'global';
+        if (!byModule[mod]) byModule[mod] = [];
+        byModule[mod].push(ep);
+      });
+
+      for (const [mod, eps] of Object.entries(byModule)) {
+        const summary = `[COMPRIMIDO] ${eps.length} episodios de ${mod}: ` +
+          eps.slice(0, 3).map(e => e.descripcion?.substring(0, 50)).join(' | ');
+
+        // Insertar resumen como nodo semántico comprimido
+        try {
+          db.prepare(`
+            INSERT OR IGNORE INTO nodos (tipo, titulo, contenido, area, confianza, estado, vigencia_tipo, fecha_creacion, fecha_update)
+            VALUES ('episodio_comprimido', ?, ?, ?, 'BAJA', 'ACTIVO', 'HISTORICO', datetime('now'), datetime('now'))
+          `).run(`Resumen episódico: ${mod} (${eps.length} eventos)`, summary, mod);
+        } catch {}
+
+        // Marcar episodios como consolidados
+        const ids = eps.map(e => e.episodio_id);
+        const placeholders = ids.map(() => '?').join(',');
+        db.prepare(`UPDATE episodios SET consolidado=1 WHERE episodio_id IN (${placeholders})`).run(...ids);
+
+        results.compressed += eps.length;
+      }
+    }
+  } catch (e) {
+    log(projectRoot, `TTL episodios error: ${e.message}`);
+  }
+
+  // 2. Episodios consolidados > 90 días → archivar (log + delete del hot store)
+  try {
+    const archiveable = db.prepare(`
+      SELECT COUNT(*) as n FROM episodios
+      WHERE consolidado = 1
+        AND julianday('now') - julianday(fecha) > 90
+    `).get()?.n || 0;
+
+    if (archiveable > 0) {
+      // Escribir archivo .jsonl antes de borrar
+      const oldEps = db.prepare(`
+        SELECT * FROM episodios
+        WHERE consolidado = 1
+          AND julianday('now') - julianday(fecha) > 90
+        LIMIT 500
+      `).all();
+
+      const archivePath = path.join(projectRoot, '.agentic', `episodios_archive_${Date.now()}.jsonl`);
+      try {
+        fs.writeFileSync(archivePath, oldEps.map(e => JSON.stringify(e)).join('\n'));
+        db.prepare(`
+          DELETE FROM episodios
+          WHERE consolidado = 1
+            AND julianday('now') - julianday(fecha) > 90
+        `).run();
+        results.archived += oldEps.length;
+      } catch {}
+    }
+  } catch {}
+
+  return results;
+}
+
+// ─── DEDUPLICACIÓN SEMÁNTICA ─────────────────────────────────────────────────
+/**
+ * Detecta nodos procedurales semánticamente duplicados.
+ * Estrategia: similitud de título + área + tipo → merge tomando el de mayor confianza.
+ *
+ * Sin acceso a embeddings reales (sin GPU): usa similitud de texto Jaccard como proxy.
+ */
+function deduplicateNodes(db, projectRoot) {
+  const results = { merged: 0, candidates: 0 };
+
+  try {
+    // Obtener nodos activos del mismo tipo y área
+    const nodes = db.prepare(`
+      SELECT id, tipo, titulo, contenido, confianza, area, aplicado, util,
+             fecha_creacion, fecha_update, vigencia_tipo
+      FROM nodos
+      WHERE estado = 'ACTIVO'
+      ORDER BY tipo, area, confianza DESC
+    `).all();
+
+    // Agrupar por tipo+área
+    const groups = {};
+    nodes.forEach(n => {
+      const key = `${n.tipo}:${n.area || 'global'}`;
+      if (!groups[key]) groups[key] = [];
+      groups[key].push(n);
+    });
+
+    for (const [key, group] of Object.entries(groups)) {
+      if (group.length < 2) continue;
+
+      for (let i = 0; i < group.length; i++) {
+        for (let j = i + 1; j < group.length; j++) {
+          const a = group[i];
+          const b = group[j];
+
+          // Similitud de Jaccard sobre palabras del título
+          const sim = jaccardSim(a.titulo || '', b.titulo || '');
+
+          if (sim >= DEDUP_THRESHOLD) {
+            results.candidates++;
+
+            // Merge: mantener el de mayor confianza, agregar frecuencia de uso
+            const winner = confRank(a.confianza) >= confRank(b.confianza) ? a : b;
+            const loser  = winner === a ? b : a;
+
+            // Actualizar el winner con la frecuencia acumulada del loser
+            try {
+              db.prepare(`
+                UPDATE nodos SET
+                  aplicado = aplicado + ?,
+                  util = util + ?,
+                  contenido = contenido || ' [MERGED: ' || ? || ']',
+                  fecha_update = datetime('now')
+                WHERE id = ?
+              `).run(loser.aplicado || 0, loser.util || 0,
+                     loser.titulo?.substring(0, 40) || '', winner.id);
+
+              // Marcar loser como OBSOLETO
+              db.prepare(`
+                UPDATE nodos SET estado='OBSOLETO', vigencia_tipo='OBSOLETO',
+                  fecha_update=datetime('now')
+                WHERE id = ?
+              `).run(loser.id);
+
+              results.merged++;
+            } catch {}
+          }
+        }
+      }
+    }
+  } catch (e) {
+    log(projectRoot, `Dedup error: ${e.message}`);
+  }
+
+  return results;
+}
+
+// ─── RESOLUCIÓN DE CONFLICTOS ─────────────────────────────────────────────────
+/**
+ * Detecta reglas contradictorias en la capa semántica.
+ * Criterio: mismo área + tipo + título similar + contenido contradictorio.
+ * Acción: marcar la más antigua como HISTORICO, conservar la más reciente.
+ */
+function resolveConflicts(db, projectRoot) {
+  const results = { resolved: 0, detected: 0 };
+
+  try {
+    // Detectar pares con alta similitud de título pero fechas diferentes
+    const nodes = db.prepare(`
+      SELECT id, tipo, titulo, contenido, confianza, area, fecha_creacion, fecha_update, vigencia_tipo
+      FROM nodos
+      WHERE estado = 'ACTIVO' AND vigencia_tipo = 'VIGENTE'
+      ORDER BY fecha_update DESC
+    `).all();
+
+    for (let i = 0; i < nodes.length; i++) {
+      for (let j = i + 1; j < nodes.length; j++) {
+        const a = nodes[i]; // más reciente
+        const b = nodes[j]; // más antiguo
+
+        if (a.tipo !== b.tipo || a.area !== b.area) continue;
+
+        const titleSim = jaccardSim(a.titulo || '', b.titulo || '');
+
+        // Títulos muy similares pero diferente contenido → posible conflicto
+        if (titleSim >= 0.7 && titleSim < DEDUP_THRESHOLD) {
+          results.detected++;
+
+          // El más antiguo pasa a HISTORICO (supersesión)
+          try {
+            db.prepare(`
+              UPDATE nodos SET
+                vigencia_tipo = 'HISTORICO',
+                contenido = contenido || ' [SUPERSEDED BY: ' || ? || ']',
+                fecha_update = datetime('now')
+              WHERE id = ?
+            `).run(a.titulo?.substring(0, 40) || '', b.id);
+
+            results.resolved++;
+          } catch {}
+        }
+      }
+    }
+  } catch (e) {
+    log(projectRoot, `Conflicts error: ${e.message}`);
+  }
+
+  return results;
+}
+
+// ─── RECALCULAR SCORES DE TODOS LOS NODOS ────────────────────────────────────
+/**
+ * Actualiza el campo decay_score de todos los nodos activos.
+ * Usa la fórmula S(k) sin query embedding (modo absoluto).
+ */
+function recalculateScores(db, projectRoot) {
+  let updated = 0;
+
+  try {
+    const nodes = db.prepare(`
+      SELECT id, confianza, aplicado, util, fecha_update, fecha_creacion
+      FROM nodos WHERE estado = 'ACTIVO'
+    `).all();
+
+    const stmt = db.prepare(`UPDATE nodos SET decay_score = ? WHERE id = ?`);
+
+    nodes.forEach(node => {
+      const scored = computeRelevanceScore(node, null, null);
+      try {
+        stmt.run(scored.score, node.id);
+        updated++;
+      } catch {}
+    });
+  } catch (e) {
+    log(projectRoot, `Score recalc error: ${e.message}`);
+  }
+
+  return { updated };
+}
+
+// ─── LIMIT NODOS PROCEDURALES ─────────────────────────────────────────────────
+/**
+ * Si hay > MAX_SEMANTIC_NODES nodos activos, deprecar los de menor score.
+ * Previene el "colapso de contexto" por grafo demasiado denso.
+ */
+function enforceNodeLimit(db, projectRoot) {
+  let deprecated = 0;
+
+  try {
+    const count = db.prepare(`SELECT COUNT(*) as n FROM nodos WHERE estado='ACTIVO'`).get()?.n || 0;
+
+    if (count > MAX_SEMANTIC_NODES) {
+      const excess = count - MAX_SEMANTIC_NODES;
+
+      // Obtener los nodos de menor score y baja utilidad
+      const candidates = db.prepare(`
+        SELECT id FROM nodos
+        WHERE estado = 'ACTIVO'
+          AND confianza = 'BAJA'
+          AND (aplicado = 0 OR (util * 1.0 / aplicado) < ?)
+        ORDER BY decay_score ASC, fecha_update ASC
+        LIMIT ?
+      `).all(MIN_UTILITY_RATIO, excess);
+
+      candidates.forEach(n => {
+        try {
+          db.prepare(`
+            UPDATE nodos SET estado='OBSOLETO', vigencia_tipo='OBSOLETO',
+              fecha_update=datetime('now')
+            WHERE id=?
+          `).run(n.id);
+          deprecated++;
+        } catch {}
+      });
+    }
+  } catch (e) {
+    log(projectRoot, `Node limit error: ${e.message}`);
+  }
+
+  return { deprecated };
+}
+
+// ─── CURATION COMPLETA ───────────────────────────────────────────────────────
+
+/**
+ * Curation completa. Se llama automáticamente cada 10 ciclos desde grafo.cjs.
+ */
+function runCuration(projectRoot) {
+  const start = Date.now();
+  projectRoot = projectRoot || process.cwd();
+
+  log(projectRoot, 'Iniciando curation...');
+
+  let db;
+  try { db = openDB(projectRoot); }
+  catch (e) { log(projectRoot, `DB error: ${e.message}`); return null; }
+
+  const report = {
+    timestamp: new Date().toISOString(),
+    ttl: null,
+    dedup: null,
+    conflicts: null,
+    scores: null,
+    node_limit: null,
+    duration_ms: 0,
+  };
+
+  try {
+    // 1. TTL enforcement (episodios viejos)
+    report.ttl = enforceEpisodicTTL(db, projectRoot);
+    log(projectRoot, `TTL: ${report.ttl.compressed} comprimidos, ${report.ttl.archived} archivados`);
+
+    // 2. Deduplicación semántica
+    report.dedup = deduplicateNodes(db, projectRoot);
+    log(projectRoot, `Dedup: ${report.dedup.merged} mergeados de ${report.dedup.candidates} candidatos`);
+
+    // 3. Resolución de conflictos
+    report.conflicts = resolveConflicts(db, projectRoot);
+    log(projectRoot, `Conflictos: ${report.conflicts.resolved} resueltos de ${report.conflicts.detected} detectados`);
+
+    // 4. Recalcular scores
+    report.scores = recalculateScores(db, projectRoot);
+    log(projectRoot, `Scores: ${report.scores.updated} nodos actualizados`);
+
+    // 5. Límite de nodos
+    report.node_limit = enforceNodeLimit(db, projectRoot);
+    if (report.node_limit.deprecated > 0) {
+      log(projectRoot, `Node limit: ${report.node_limit.deprecated} nodos deprecados`);
+    }
+
+  } catch (e) {
+    log(projectRoot, `Curation error: ${e.message}`);
+  }
+
+  report.duration_ms = Date.now() - start;
+  log(projectRoot, `Curation completa en ${report.duration_ms}ms`);
+
+  return report;
+}
+
+// ─── REPORTE SIN CAMBIOS ─────────────────────────────────────────────────────
+
+function generateReport(projectRoot) {
+  projectRoot = projectRoot || process.cwd();
+  const db = openDB(projectRoot);
+
+  // Episodios sin consolidar
+  const staleEpisodes = db.prepare(`
+    SELECT COUNT(*) as n FROM episodios
+    WHERE consolidado = 0
+      AND julianday('now') - julianday(fecha) > ?
+  `).get(TTL_EPISODIC_DAYS)?.n || 0;
+
+  // Nodos activos
+  const activeNodes = db.prepare(`SELECT COUNT(*) as n FROM nodos WHERE estado='ACTIVO'`).get()?.n || 0;
+
+  // Nodos BAJA confianza con baja utilidad
+  const lowUtility = db.prepare(`
+    SELECT COUNT(*) as n FROM nodos
+    WHERE estado='ACTIVO' AND confianza='BAJA'
+      AND aplicado >= 3 AND (util * 1.0 / aplicado) < ?
+  `).get(MIN_UTILITY_RATIO)?.n || 0;
+
+  // Nodos sin vigencia_tipo
+  let unclassified = 0;
+  try {
+    unclassified = db.prepare(`
+      SELECT COUNT(*) as n FROM nodos
+      WHERE estado='ACTIVO' AND (vigencia_tipo IS NULL OR vigencia_tipo = '')
+    `).get()?.n || 0;
+  } catch {}
+
+  return {
+    active_nodes: activeNodes,
+    stale_episodes: staleEpisodes,
+    low_utility_candidates: lowUtility,
+    unclassified_vigencia: unclassified,
+    over_limit: activeNodes > MAX_SEMANTIC_NODES,
+    needs_curation: staleEpisodes > 50 || lowUtility > 20 || activeNodes > MAX_SEMANTIC_NODES,
+  };
+}
+
+// ─── HELPERS ─────────────────────────────────────────────────────────────────
+
+function jaccardSim(a, b) {
+  const setA = new Set(a.toLowerCase().split(/\W+/).filter(Boolean));
+  const setB = new Set(b.toLowerCase().split(/\W+/).filter(Boolean));
+  const intersection = new Set([...setA].filter(x => setB.has(x)));
+  const union = new Set([...setA, ...setB]);
+  return union.size === 0 ? 0 : intersection.size / union.size;
+}
+
+function confRank(c) {
+  return { 'ALTA': 3, 'MEDIA': 2, 'BAJA': 1 }[c] || 0;
+}
+
+// ─── CLI ──────────────────────────────────────────────────────────────────────
+
+if (require.main === module) {
+  const [,, cmd] = process.argv;
+  const projectRoot = process.cwd();
+
+  switch (cmd) {
+    case 'run': {
+      const r = runCuration(projectRoot);
+      if (r) {
+        console.log('\n=== MemCurator Report ===');
+        console.log(`TTL:       ${r.ttl?.compressed} comprimidos, ${r.ttl?.archived} archivados`);
+        console.log(`Dedup:     ${r.dedup?.merged} mergeados`);
+        console.log(`Conflictos:${r.conflicts?.resolved} resueltos`);
+        console.log(`Scores:    ${r.scores?.updated} actualizados`);
+        console.log(`Duración:  ${r.duration_ms}ms\n`);
+      }
+      break;
+    }
+    case 'ttl': {
+      const db = openDB(projectRoot);
+      const r = enforceEpisodicTTL(db, projectRoot);
+      console.log(`TTL: ${r.compressed} comprimidos, ${r.archived} archivados`);
+      break;
+    }
+    case 'dedup': {
+      const db = openDB(projectRoot);
+      const r = deduplicateNodes(db, projectRoot);
+      console.log(`Dedup: ${r.merged} mergeados de ${r.candidates} candidatos`);
+      break;
+    }
+    case 'conflicts': {
+      const db = openDB(projectRoot);
+      const r = resolveConflicts(db, projectRoot);
+      console.log(`Conflictos: ${r.resolved} resueltos de ${r.detected} detectados`);
+      break;
+    }
+    case 'score': {
+      const db = openDB(projectRoot);
+      const r = recalculateScores(db, projectRoot);
+      console.log(`Scores: ${r.updated} nodos actualizados`);
+      break;
+    }
+    case 'report': {
+      const r = generateReport(projectRoot);
+      console.log('\n=== MemCurator Pre-Report ===');
+      console.log(`Nodos activos:          ${r.active_nodes}`);
+      console.log(`Episodios stale:        ${r.stale_episodes}`);
+      console.log(`Candidatos baja util:   ${r.low_utility_candidates}`);
+      console.log(`Sin vigencia_tipo:      ${r.unclassified_vigencia}`);
+      console.log(`Sobre límite:           ${r.over_limit}`);
+      console.log(`Necesita curation:      ${r.needs_curation}`);
+      console.log('\nPara curar: node mem-curator.cjs run\n');
+      break;
+    }
+    default:
+      console.log('Uso: node mem-curator.cjs [run | ttl | dedup | conflicts | score | report]');
+  }
+}
+
+module.exports = {
+  runCuration,
+  enforceEpisodicTTL,
+  deduplicateNodes,
+  resolveConflicts,
+  recalculateScores,
+  enforceNodeLimit,
+  computeRelevanceScore,
+  generateReport,
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-kdd",
-  "version": "3.0.4",
+  "version": "3.1.1",
   "description": "Autonomous development pipeline — aa: · ag: · audit: · AST graph · Harness · Specs · Impact analysis · Decision trail · Metrics · MCP server. Works with Cursor and Claude Code.",
   "main": "src/index.js",
   "bin": {