agentic-kdd 3.5.6 → 3.5.8

package/mem-curator.cjs

@@ -1,584 +1,361 @@
+'use strict';
 /**
- * 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
- *
+ * Agentic KDD — Memory Curator v2.0
+ * Curación automática real: deduplicación, scoring por relevancia, expiración.
+ * 
+ * Principio: 30 entradas precisas > 300 entradas ruidosas.
+ * 
  * 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
+ *   node .agentic/grafo/mem-curator.cjs run        → cura completa
+ *   node .agentic/grafo/mem-curator.cjs report     → solo reporte, no modifica
+ *   node .agentic/grafo/mem-curator.cjs dedup      → solo deduplicar
+ *   node .agentic/grafo/mem-curator.cjs score      → solo recalcular scores
+ *   node .agentic/grafo/mem-curator.cjs expire     → solo expirar entradas viejas
  */
 
-'use strict';
-
-const path = require('path');
 const fs   = require('fs');
+const path = require('path');
+
+const ROOT         = process.cwd();
+const MEMORIA_DIR  = path.join(ROOT, '.agentic', 'memoria');
+const ERRORES_FILE = path.join(MEMORIA_DIR, 'errores.md');
+const PATRONES_FILE= path.join(MEMORIA_DIR, 'patrones.md');
+const DECISIONES_FILE = path.join(MEMORIA_DIR, 'decisiones.md');
+
+// ── Configuración de curación ───────────────────────────────────────────────
+
+const CONFIG = {
+  // Días sin referencias antes de marcar como candidato a expiración
+  EXPIRY_DAYS_LOW_SCORE:  90,
+  EXPIRY_DAYS_HIGH_SCORE: 365,
+  // Número máximo de entradas por archivo antes de forzar curación
+  MAX_ENTRIES_ERRORS:   50,
+  MAX_ENTRIES_PATTERNS: 40,
+  MAX_ENTRIES_DECISIONS:30,
+  // Umbral de similitud para considerar duplicado (0-1)
+  SIMILARITY_THRESHOLD: 0.75,
+};
 
-// ─── CONSTANTES ───────────────────────────────────────────────────────────────
+// ── Parser de archivos de memoria ───────────────────────────────────────────
 
-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';
+function parseMemoryFile(filePath) {
+  if (!fs.existsSync(filePath)) return [];
 
-// ─── DB HELPER ────────────────────────────────────────────────────────────────
+  const content = fs.readFileSync(filePath, 'utf8');
+  const entries = [];
 
-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');
-}
+  // Detectar entradas por bloques --- o por encabezados ###
+  const blocks = content.split(/\n(?=###\s|---\s*\n###)/);
 
-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}`);
-}
+  for (const block of blocks) {
+    const titleMatch = block.match(/###\s+(.+)/);
+    if (!titleMatch) continue;
 
-// ─── 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 entry = {
+      title:      titleMatch[1].trim(),
+      raw:        block,
+      confidence: extractField(block, 'confianza') || extractField(block, 'confidence') || 'MEDIA',
+      date:       extractField(block, 'fecha') || extractField(block, 'date') || null,
+      references: parseInt(extractField(block, 'referencias') || '0'),
+      module:     extractField(block, 'módulo') || extractField(block, 'module') || 'global',
+      score:      0,
+    };
+
+    entry.score = computeScore(entry);
+    entries.push(entry);
   }
 
-  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),
-    },
-  };
+  return entries;
 }
 
-// ─── 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 };
+function extractField(text, field) {
+  const regex = new RegExp(`\\*\\*${field}\\*\\*:\\s*(.+)`, 'i');
+  const match = text.match(regex);
+  return match ? match[1].trim() : null;
+}
 
-  // 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}`);
+// ── Scoring ──────────────────────────────────────────────────────────────────
+
+function computeScore(entry) {
+  let score = 0;
+
+  // Confianza base
+  if (entry.confidence === 'ALTA')  score += 40;
+  if (entry.confidence === 'MEDIA') score += 20;
+  if (entry.confidence === 'BAJA')  score += 5;
+
+  // Referencias acumuladas
+  score += Math.min(entry.references * 5, 30);
+
+  // Penalización por antigüedad
+  if (entry.date) {
+    const daysSince = daysSinceDate(entry.date);
+    if (daysSince > 180) score -= 10;
+    if (daysSince > 365) score -= 20;
   }
 
-  // 2. Episodios consolidados > 90 días → archivar (log + delete del hot store)
+  // Bonus por módulo global
+  if (entry.module === 'global') score += 5;
+
+  return Math.max(0, score);
+}
+
+function daysSinceDate(dateStr) {
   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 {}
+    const d = new Date(dateStr);
+    return Math.floor((Date.now() - d.getTime()) / (1000 * 60 * 60 * 24));
+  } catch { return 0; }
+}
+
+// ── Deduplicación ────────────────────────────────────────────────────────────
+
+function cosineSimilarity(a, b) {
+  const wordsA = tokenize(a);
+  const wordsB = tokenize(b);
+  const vocab  = [...new Set([...wordsA, ...wordsB])];
 
-  return results;
+  const vecA = vocab.map(w => wordsA.filter(x => x === w).length);
+  const vecB = vocab.map(w => wordsB.filter(x => x === w).length);
+
+  const dot    = vecA.reduce((s, v, i) => s + v * vecB[i], 0);
+  const magA   = Math.sqrt(vecA.reduce((s, v) => s + v * v, 0));
+  const magB   = Math.sqrt(vecB.reduce((s, v) => s + v * v, 0));
+
+  return (magA && magB) ? dot / (magA * magB) : 0;
 }
 
-// ─── 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 };
+function tokenize(text) {
+  return text.toLowerCase()
+    .replace(/[^a-z0-9áéíóúñü\s]/g, ' ')
+    .split(/\s+/)
+    .filter(w => w.length > 3);
+}
 
-  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 {}
-          }
+function deduplicateEntries(entries) {
+  const kept    = [];
+  const removed = [];
+
+  for (let i = 0; i < entries.length; i++) {
+    let isDuplicate = false;
+
+    for (let j = 0; j < kept.length; j++) {
+      const sim = cosineSimilarity(entries[i].title + ' ' + entries[i].raw,
+                                   kept[j].title   + ' ' + kept[j].raw);
+      if (sim >= CONFIG.SIMILARITY_THRESHOLD) {
+        // Keep the one with higher score
+        if (entries[i].score > kept[j].score) {
+          removed.push(kept[j]);
+          kept[j] = entries[i];
+        } else {
+          removed.push(entries[i]);
         }
+        isDuplicate = true;
+        break;
       }
     }
-  } catch (e) {
-    log(projectRoot, `Dedup error: ${e.message}`);
+
+    if (!isDuplicate) kept.push(entries[i]);
   }
 
-  return results;
+  return { kept, removed };
 }
 
-// ─── 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 };
+// ── Expiración ───────────────────────────────────────────────────────────────
 
-  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 {}
-        }
+function expireEntries(entries) {
+  const now     = Date.now();
+  const kept    = [];
+  const expired = [];
+
+  for (const entry of entries) {
+    const maxDays = entry.score >= 40
+      ? CONFIG.EXPIRY_DAYS_HIGH_SCORE
+      : CONFIG.EXPIRY_DAYS_LOW_SCORE;
+
+    if (entry.date) {
+      const days = daysSinceDate(entry.date);
+      if (days > maxDays && entry.confidence === 'BAJA') {
+        expired.push(entry);
+        continue;
       }
     }
-  } catch (e) {
-    log(projectRoot, `Conflicts error: ${e.message}`);
+
+    kept.push(entry);
   }
 
-  return results;
+  return { kept, expired };
 }
 
-// ─── 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;
+// ── Reconstruir archivo ──────────────────────────────────────────────────────
 
-  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}`);
+function rebuildFile(filePath, entries, headerLines) {
+  // Sort by score descending
+  const sorted = [...entries].sort((a, b) => b.score - a.score);
+
+  const lines = [];
+  if (headerLines) lines.push(...headerLines, '');
+
+  for (const entry of sorted) {
+    lines.push(entry.raw.trim());
+    lines.push('');
   }
 
-  return { updated };
+  fs.writeFileSync(filePath, lines.join('\n'), 'utf8');
 }
 
-// ─── 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}`);
+function extractHeader(filePath) {
+  if (!fs.existsSync(filePath)) return [];
+  const content = fs.readFileSync(filePath, 'utf8');
+  const lines = content.split('\n');
+  const headerLines = [];
+  for (const line of lines) {
+    if (line.startsWith('### ')) break;
+    headerLines.push(line);
   }
-
-  return { deprecated };
+  return headerLines;
 }
 
-// ─── CURATION COMPLETA ───────────────────────────────────────────────────────
+// ── Curación principal ───────────────────────────────────────────────────────
 
-/**
- * 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,
+function curateFile(filePath, maxEntries, label) {
+  const result = {
+    file: label,
+    before: 0, after: 0,
+    deduped: 0, expired: 0, sorted: true,
+    changes: [],
   };
 
-  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`);
-    }
+  if (!fs.existsSync(filePath)) {
+    result.changes.push('archivo no encontrado — sin cambios');
+    return result;
+  }
+
+  const header  = extractHeader(filePath);
+  const entries = parseMemoryFile(filePath);
+  result.before = entries.length;
+
+  // 1. Recalcular scores
+  entries.forEach(e => { e.score = computeScore(e); });
 
-  } catch (e) {
-    log(projectRoot, `Curation error: ${e.message}`);
+  // 2. Deduplicar
+  const { kept: afterDedup, removed } = deduplicateEntries(entries);
+  result.deduped = removed.length;
+  if (removed.length > 0) {
+    result.changes.push(`${removed.length} duplicados eliminados`);
   }
 
-  report.duration_ms = Date.now() - start;
-  log(projectRoot, `Curation completa en ${report.duration_ms}ms`);
+  // 3. Expirar
+  const { kept: afterExpire, expired } = expireEntries(afterDedup);
+  result.expired = expired.length;
+  if (expired.length > 0) {
+    result.changes.push(`${expired.length} entradas expiradas (BAJA confianza, sin uso)`);
+  }
+
+  // 4. Si supera máximo, descartar las de menor score
+  let finalEntries = afterExpire;
+  if (finalEntries.length > maxEntries) {
+    const cutoff = finalEntries.length - maxEntries;
+    result.changes.push(`${cutoff} entradas de bajo score descartadas (límite: ${maxEntries})`);
+    finalEntries = finalEntries.sort((a, b) => b.score - a.score).slice(0, maxEntries);
+  }
 
-  return report;
+  result.after = finalEntries.length;
+
+  // 5. Reescribir ordenado por score
+  rebuildFile(filePath, finalEntries, header);
+
+  if (result.changes.length === 0) {
+    result.changes.push('sin cambios necesarios');
+  }
+
+  return result;
 }
 
-// ─── REPORTE SIN CAMBIOS ─────────────────────────────────────────────────────
+// ── Report ───────────────────────────────────────────────────────────────────
 
-function generateReport(projectRoot) {
-  projectRoot = projectRoot || process.cwd();
-  const db = openDB(projectRoot);
+function report() {
+  console.log('\n══════════════════════════════════════════════════');
+  console.log('  🧠 Memory Curator — Análisis');
+  console.log('══════════════════════════════════════════════════');
 
-  // 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;
+  const files = [
+    { path: ERRORES_FILE,    label: 'errores.md',    max: CONFIG.MAX_ENTRIES_ERRORS    },
+    { path: PATRONES_FILE,   label: 'patrones.md',   max: CONFIG.MAX_ENTRIES_PATTERNS  },
+    { path: DECISIONES_FILE, label: 'decisiones.md', max: CONFIG.MAX_ENTRIES_DECISIONS },
+  ];
 
-  // Nodos activos
-  const activeNodes = db.prepare(`SELECT COUNT(*) as n FROM nodos WHERE estado='ACTIVO'`).get()?.n || 0;
+  for (const f of files) {
+    const entries = parseMemoryFile(f.path);
+    console.log(`\n  📄 ${f.label}: ${entries.length} entradas`);
 
-  // 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;
+    if (entries.length === 0) {
+      console.log('     (vacío)');
+      continue;
+    }
 
-  // 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,
-  };
-}
+    const sorted = [...entries].sort((a, b) => b.score - a.score);
+    const high   = sorted.filter(e => e.score >= 40).length;
+    const med    = sorted.filter(e => e.score >= 20 && e.score < 40).length;
+    const low    = sorted.filter(e => e.score < 20).length;
 
-// ─── HELPERS ─────────────────────────────────────────────────────────────────
+    console.log(`     Score ALTO (≥40): ${high} | MEDIO (20-39): ${med} | BAJO (<20): ${low}`);
+    if (entries.length > f.max) {
+      console.log(`     ⚠️  Supera límite (${f.max}) — curación recomendada`);
+    }
 
-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;
-}
+    // Show duplicates preview
+    const { removed } = deduplicateEntries(entries);
+    if (removed.length > 0) {
+      console.log(`     🔁 Posibles duplicados: ${removed.length}`);
+    }
+  }
 
-function confRank(c) {
-  return { 'ALTA': 3, 'MEDIA': 2, 'BAJA': 1 }[c] || 0;
+  console.log('\n══════════════════════════════════════════════════\n');
 }
 
-// ─── CLI ──────────────────────────────────────────────────────────────────────
+// ── 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`);
+  const cmd = process.argv[2] || 'run';
+
+  if (cmd === 'report') {
+    report();
+    process.exit(0);
+  }
+
+  if (cmd === 'run' || cmd === 'dedup' || cmd === 'score' || cmd === 'expire') {
+    console.log('\n══════════════════════════════════════════════════');
+    console.log('  🧠 Memory Curator — Curación');
+    console.log('══════════════════════════════════════════════════\n');
+
+    const files = [
+      { path: ERRORES_FILE,    max: CONFIG.MAX_ENTRIES_ERRORS,    label: 'errores.md'    },
+      { path: PATRONES_FILE,   max: CONFIG.MAX_ENTRIES_PATTERNS,  label: 'patrones.md'   },
+      { path: DECISIONES_FILE, max: CONFIG.MAX_ENTRIES_DECISIONS, label: 'decisiones.md' },
+    ];
+
+    let totalRemoved = 0;
+
+    for (const f of files) {
+      const result = curateFile(f.path, f.max, f.label);
+      totalRemoved += result.deduped + result.expired;
+
+      const delta = result.before - result.after;
+      console.log(`  ${f.label}:`);
+      console.log(`    Antes: ${result.before} → Después: ${result.after} (${delta > 0 ? '-' + delta : 'sin cambio'})`);
+      for (const c of result.changes) {
+        console.log(`    ✓ ${c}`);
       }
-      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;
+      console.log('');
     }
-    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]');
+
+    console.log(`  Total eliminadas: ${totalRemoved}`);
+    console.log('══════════════════════════════════════════════════\n');
+
+    process.exit(0);
   }
+
+  console.log('Uso: node mem-curator.cjs [run|report|dedup|score|expire]');
 }
 
-module.exports = {
-  runCuration,
-  enforceEpisodicTTL,
-  deduplicateNodes,
-  resolveConflicts,
-  recalculateScores,
-  enforceNodeLimit,
-  computeRelevanceScore,
-  generateReport,
-};
+module.exports = { curateFile, parseMemoryFile, computeScore, deduplicateEntries, expireEntries };