agentic-kdd 2.1.10 → 2.1.11

package/bin/akdd.js

@@ -25,8 +25,12 @@ const HELP = `
     akdd graph         Sync memory + show graph stats
     akdd sync          Sync memory files to SQLite graph
     akdd stats         Show graph stats and HIGH rules
+    akdd coala         Show CoALA memory stats (procedural + episodic + semantic)
     akdd metricas      Show agent KPIs (Goal Attainment, Autonomy, etc.)
-    akdd semantico     Semantic search in knowledge graph (needs API key)
+    akdd buscar        Hybrid search across all 3 memory layers
+    akdd impacto       Show impact of touching a module/file
+    akdd semantico     Semantic search (needs API key)
+    akdd decay         Apply temporal decay to stale patterns
     akdd dashboard     Open visual dashboard in browser
     akdd --version     Show version
     akdd --help        Show this help
@@ -71,6 +75,9 @@ switch (command) {
   case 'stats':
     runGrafo('stats');
     break;
+  case 'coala':
+    runGrafo('coala');
+    break;
   case 'metricas':
     runGrafo('metricas');
     break;
@@ -78,6 +85,17 @@ switch (command) {
     if (!arg1) { console.log('\n  Uso: akdd semantico "tu query"\n'); break; }
     runGrafo('semantico', `"${arg1}"`);
     break;
+  case 'buscar':
+    if (!arg1) { console.log('\n  Uso: akdd buscar "query" [area]\n'); break; }
+    runGrafo('buscar', `"${arg1}"${arg2 ? ' ' + arg2 : ''}`);
+    break;
+  case 'impacto':
+    if (!arg1) { console.log('\n  Uso: akdd impacto "NombreModulo"\n'); break; }
+    runGrafo('impacto', `"${arg1}"`);
+    break;
+  case 'decay':
+    runGrafo('decay');
+    break;
   case 'dashboard':
     dashboard();
     break;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentic-kdd",
-  "version": "2.1.10",
+  "version": "2.1.11",
   "description": "Autonomous development pipeline with KDD — aa: · ag: · audit: · Visual Dashboard. Works with Cursor and Claude Code.",
   "main": "src/index.js",
   "bin": {

package/src/init.js

@@ -254,6 +254,18 @@ async function init() {
     console.log(chalk.gray('  Agentic los usará automáticamente en el siguiente aa:'));
   }
 
+  // ── CREAR config.md BASE ────────────────────────────────────
+  // Necesario para que akdd graph funcione antes de aa: configurar
+  const configPath = path.join(projectPath, '.agentic', 'config.md');
+  if (!fs.existsSync(configPath)) {
+    fs.writeFileSync(configPath, `# Configuración del proyecto
+CONFIGURADO: SI
+Nombre: ${name}
+Stack: ${stack.framework} · ${stack.language} · ${stack.packageManager}
+Estado: Pendiente aa: configurar
+`);
+  }
+
   // ── RESUMEN FINAL ───────────────────────────────────────────
   console.log('\n' + chalk.bold('  Instalado:'));
   console.log(chalk.gray('  .agentic/agentes/      — pipeline de 9 agentes'));

package/templates/.agentic/grafo/grafo.cjs

@@ -294,6 +294,52 @@ function sincronizar() {
   }
   if (db.type === 'sqljs' && db.save) db.save();
   detectarRelaciones(db);
+  // Gap CoALA: consolidación episódica automática
+  // Episodios "resuelto" sin consolidar → extraer como patrones/errores
+  try {
+    const episodiosPendientes = db.all(
+      `SELECT * FROM episodios WHERE consolidado=0 AND resultado='resuelto' 
+       AND tipo IN ('fix','error') ORDER BY fecha DESC LIMIT 20`
+    );
+    episodiosPendientes.forEach(ep => {
+      try {
+        // Solo consolidar si tiene suficiente info
+        if (!ep.descripcion || !ep.accion_tomada) return;
+        const titulo = `[EP] ${ep.descripcion.slice(0, 80)}`;
+        const ex = db.get('SELECT id FROM nodos WHERE titulo=?', titulo);
+        if (!ex) {
+          const contenido = `## ${ep.fecha.split('T')[0]} [EP] ${ep.descripcion}
+Área: ${ep.area || 'global'}
+Confianza: BAJA
+Estado: ACTIVO
+Origen: consolidado de episodio
+Fix aplicado: ${ep.accion_tomada}
+Razón: ${ep.razon_resultado || 'ver episodio original'}`;
+          db.run(`INSERT INTO nodos (tipo,titulo,contenido,area,confianza,aplicado,util,estado,ultima_validacion,fecha_update) 
+                  VALUES (?,?,?,?,?,?,?,?,datetime('now'),datetime('now'))`,
+            'error', titulo, contenido, ep.area || 'global', 'BAJA', 1, 1, 'ACTIVO');
+          const nodoId = (db.get('SELECT id FROM nodos WHERE titulo=?', titulo) || {}).id;
+          if (nodoId) {
+            db.run('UPDATE episodios SET consolidado=1, nodo_generado_id=? WHERE id=?', nodoId, ep.id);
+          }
+        }
+      } catch(e) {}
+    });
+  } catch(e) {}
+  // Gap CoALA: decay automático — patrones sin uso pierden relevancia
+  try {
+    const ahora = Date.now();
+    const nodos = db.all("SELECT id, ultimo_acceso, fecha_creacion, aplicado, confianza FROM nodos WHERE estado='ACTIVO'");
+    nodos.forEach(n => {
+      const base = n.ultimo_acceso || n.fecha_creacion;
+      const dias = base ? (ahora - new Date(base).getTime()) / (1000*60*60*24) : 0;
+      const tasa = { 'ALTA': 0.003, 'MEDIA': 0.008, 'BAJA': 0.015 }[n.confianza] || 0.01;
+      const decay = Math.max(0.1, 1.0 - (dias * tasa));
+      let estado = 'ACTIVO';
+      if (decay < 0.3 && n.confianza === 'BAJA' && (n.aplicado || 0) === 0) estado = 'OBSOLETO';
+      try { db.run('UPDATE nodos SET decay_score=?, estado=? WHERE id=?', decay, estado, n.id); } catch(e) {}
+    });
+  } catch(e) {}
   // Forzar checkpoint WAL para que los datos queden en la DB principal
   try { db.exec('PRAGMA wal_checkpoint(TRUNCATE)'); } catch(e) {}
   db.close();
@@ -828,12 +874,72 @@ Razón: Dependencia confirmada en package.json`;
 
   // Detectar relaciones entre nodos nuevos
   detectarRelaciones(db);
+
+  // ── 7. MEMORIA SEMÁNTICA — entidades y relaciones del proyecto ────────────
+  // Gap CoALA: analizarProyecto ahora llena entidades y relaciones_semanticas
+  const archivosConImports = {};
+  function recorrerParaEntidades(dir, nivel) {
+    if (nivel > 5) return;
+    let items; try { items = fs.readdirSync(dir); } catch(e) { return; }
+    for (const item of items) {
+      if (ignorar.has(item) || item.startsWith('.')) continue;
+      const full = path.join(dir, item);
+      let stat; try { stat = fs.statSync(full); } catch(e) { continue; }
+      if (stat.isDirectory()) {
+        recorrerParaEntidades(full, nivel + 1);
+      } else if (stat.isFile() && extsCodigo.has(path.extname(item).toLowerCase())) {
+        let content; try { content = fs.readFileSync(full, 'utf8'); } catch(e) { continue; }
+        const relPath = path.relative(ROOT, full).replace(/\\/g, '/');
+        const nombre = path.basename(item, path.extname(item));
+        const area = inferirArea(full);
+        // Registrar entidad
+        const esTest = /\.test\.|\.spec\./.test(item);
+        const esCritico = ['middleware','auth','session','database','config','index','app','main','server'].some(k => nombre.toLowerCase().includes(k));
+        try {
+          const ex = db.get('SELECT id FROM entidades WHERE nombre=?', nombre);
+          if (!ex) {
+            db.run(`INSERT INTO entidades (nombre, tipo, descripcion, area, propiedades, critica, fecha_creacion, fecha_update) VALUES (?,?,?,?,?,?,datetime('now'),datetime('now'))`,
+              nombre,
+              esTest ? 'test' : 'archivo',
+              `Archivo: ${relPath}`,
+              area,
+              JSON.stringify({ ruta: relPath, extension: path.extname(item) }),
+              esCritico ? 1 : 0
+            );
+            nodosCreados++;
+          }
+        } catch(e) {}
+        // Detectar imports locales para relaciones semánticas
+        const importLocales = [];
+        const rxLocal = /(?:import|require)\s*(?:.*?\s+from\s+)?['"](\.[^'"]+)['"]/g;
+        let m; while ((m = rxLocal.exec(content)) !== null) {
+          const importado = path.basename(m[1]).replace(/\.[^.]+$/, '') || path.basename(m[1]);
+          if (importado && importado !== nombre) importLocales.push(importado);
+        }
+        archivosConImports[nombre] = importLocales;
+      }
+    }
+  }
+  recorrerParaEntidades(ROOT, 0);
+
+  // Registrar relaciones semánticas basadas en imports
+  Object.entries(archivosConImports).forEach(([desde, imports]) => {
+    imports.forEach(hacia => {
+      try {
+        db.run(`INSERT OR IGNORE INTO relaciones_semanticas (desde_entidad, tipo, hacia_entidad, peso) VALUES (?,?,?,?)`,
+          desde, 'importa', hacia, 1.0);
+      } catch(e) {}
+    });
+  });
+
   if (db.type === 'sqljs' && db.save) db.save();
 
   // Actualizar archivos .md de memoria con lo detectado
   actualizarMemoriaMd(patronesEncontrados, decisionesEncontradas, stackInfo, fecha);
 
   const totalNodos = (db.get('SELECT COUNT(*) as n FROM nodos') || {}).n || 0;
+  const totalEntidades = (() => { try { return (db.get('SELECT COUNT(*) as n FROM entidades') || {}).n || 0; } catch(e) { return 0; } })();
+  const totalRelSem = (() => { try { return (db.get('SELECT COUNT(*) as n FROM relaciones_semanticas') || {}).n || 0; } catch(e) { return 0; } })();
   db.close();
 
   // ── OUTPUT ─────────────────────────────────────────────────────────────────
@@ -848,6 +954,9 @@ Razón: Dependencia confirmada en package.json`;
     .forEach(([p,d]) => console.log(`    [${d.count}x] ${p}`));
   console.log(`\n  Decisiones inferidas: ${Object.keys(decisionesEncontradas).length}`);
   Object.keys(decisionesEncontradas).forEach(d => console.log(`    ~ ${d}`));
+  console.log(`\n  Memoria semántica:`);
+  console.log(`    Entidades: ${totalEntidades} archivos/módulos mapeados`);
+  console.log(`    Relaciones: ${totalRelSem} dependencias entre archivos`);
   console.log(`\n  Nodos nuevos en grafo: ${nodosCreados} (total: ${totalNodos})`);
   console.log(`\n  Dashboard actualizado — corre: node dashboard.cjs\n`);
 }
@@ -916,3 +1025,307 @@ Razón: Inferido del código — verificar con el equipo\n`;
 }
 
 module.exports = { sincronizar, consultar, stats, metricas, registrarCiclo, buscarSemantico, snapshotMemoria, analizarProyecto };
+
+// ─── CoALA v3: MEMORIA EPISÓDICA ──────────────────────────────────────────
+function registrarEpisodio(datos) {
+  try {
+    const db = initDB();
+    const episodio_id = (crypto.randomUUID ? crypto.randomUUID() : Date.now().toString(36) + Math.random().toString(36).slice(2));
+    db.run(`INSERT INTO episodios 
+      (episodio_id, ciclo_id, sesion_id, tipo, descripcion, intento_num, 
+       contexto_antes, accion_tomada, resultado, razon_resultado, 
+       archivos_tocados, area, modulo, relevancia)
+      VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?)`,
+      episodio_id,
+      datos.ciclo_id || null,
+      datos.sesion_id || null,
+      datos.tipo || 'accion',
+      datos.descripcion || '',
+      datos.intento_num || 1,
+      datos.contexto_antes || null,
+      datos.accion_tomada || null,
+      datos.resultado || null,
+      datos.razon_resultado || null,
+      JSON.stringify(datos.archivos_tocados || []),
+      datos.area || 'global',
+      datos.modulo || 'global',
+      datos.relevancia || 1.0
+    );
+    if (db.type === 'sqljs' && db.save) db.save();
+    db.close();
+    return episodio_id;
+  } catch(e) { console.error('Error registrarEpisodio:', e.message); return null; }
+}
+
+// Consolidar episodios → patrones/decisiones (episódica → procedural)
+// Agentmemory lo hace con barridos horarios; aquí lo hacemos por demanda
+function consolidarEpisodios(area) {
+  try {
+    const db = initDB();
+    const filtro = area && area !== 'global' ? `AND area='${area}'` : '';
+    const episodios = db.all(
+      `SELECT * FROM episodios WHERE consolidado=0 ${filtro} ORDER BY fecha DESC LIMIT 50`
+    );
+    if (!episodios.length) { db.close(); return { consolidados: 0, episodios: [] }; }
+    // Devolver los episodios sin consolidar para que el agente Memoria los procese
+    // El agente decide cuáles merecen convertirse en patrones/decisiones
+    db.close();
+    return { consolidados: episodios.length, episodios };
+  } catch(e) { return { consolidados: 0, episodios: [] }; }
+}
+
+// Marcar episodio como consolidado (después de que el agente lo procesó)
+function marcarEpisodioConsolidado(episodio_id, nodo_id) {
+  try {
+    const db = initDB();
+    db.run('UPDATE episodios SET consolidado=1, nodo_generado_id=? WHERE episodio_id=?', 
+      nodo_id || null, episodio_id);
+    if (db.type === 'sqljs' && db.save) db.save();
+    db.close();
+    return true;
+  } catch(e) { return false; }
+}
+
+// ─── CoALA v3: MEMORIA SEMÁNTICA (grafo de entidades) ────────────────────
+function registrarEntidad(datos) {
+  try {
+    const db = initDB();
+    const ex = db.get('SELECT id FROM entidades WHERE nombre=?', datos.nombre);
+    if (ex) {
+      db.run(`UPDATE entidades SET tipo=?, descripcion=?, area=?, propiedades=?, 
+              modificaciones=modificaciones+1, fecha_update=datetime('now') WHERE nombre=?`,
+        datos.tipo || 'modulo',
+        datos.descripcion || null,
+        datos.area || 'global',
+        JSON.stringify(datos.propiedades || {}),
+        datos.nombre
+      );
+    } else {
+      db.run(`INSERT INTO entidades (nombre, tipo, descripcion, area, propiedades, critica)
+              VALUES (?,?,?,?,?,?)`,
+        datos.nombre,
+        datos.tipo || 'modulo',
+        datos.descripcion || null,
+        datos.area || 'global',
+        JSON.stringify(datos.propiedades || {}),
+        datos.critica ? 1 : 0
+      );
+    }
+    if (db.type === 'sqljs' && db.save) db.save();
+    db.close();
+    return true;
+  } catch(e) { return false; }
+}
+
+function registrarRelacionSemantica(desde, tipo, hacia, descripcion, peso) {
+  try {
+    const db = initDB();
+    db.run(`INSERT OR REPLACE INTO relaciones_semanticas 
+            (desde_entidad, tipo, hacia_entidad, peso, descripcion)
+            VALUES (?,?,?,?,?)`,
+      desde, tipo, hacia, peso || 1.0, descripcion || null
+    );
+    if (db.type === 'sqljs' && db.save) db.save();
+    db.close();
+    return true;
+  } catch(e) { return false; }
+}
+
+// Consultar impacto de tocar una entidad (qué más puede romperse)
+function impactoEntidad(nombre) {
+  try {
+    const db = initDB();
+    const entidad = db.get('SELECT * FROM entidades WHERE nombre=?', nombre);
+    if (!entidad) { db.close(); return null; }
+    // Qué depende de esta entidad
+    const dependientes = db.all(
+      `SELECT desde_entidad, tipo, descripcion FROM relaciones_semanticas 
+       WHERE hacia_entidad=? ORDER BY tipo`,
+      nombre
+    );
+    // Qué depende esta entidad  
+    const dependencias = db.all(
+      `SELECT hacia_entidad, tipo, descripcion FROM relaciones_semanticas 
+       WHERE desde_entidad=? ORDER BY tipo`,
+      nombre
+    );
+    // Errores asociados a esta entidad
+    const errores = db.all(
+      `SELECT titulo, confianza FROM nodos 
+       WHERE tipo='error' AND (area=? OR contenido LIKE ?) AND estado='ACTIVO' LIMIT 5`,
+      entidad.area, `%${nombre}%`
+    );
+    db.close();
+    return { entidad, dependientes, dependencias, errores };
+  } catch(e) { return null; }
+}
+
+// ─── CoALA v3: DECAY TEMPORAL ─────────────────────────────────────────────
+// Los patrones que no se usan pierden relevancia gradualmente
+// Inspirado en ACT-R activation decay: A(t) = ln(Σ t_i^-d) 
+function aplicarDecay() {
+  try {
+    const db = initDB();
+    const ahora = Date.now();
+    const nodos = db.all("SELECT id, ultimo_acceso, aplicado, confianza FROM nodos WHERE estado='ACTIVO'");
+    
+    nodos.forEach(n => {
+      const diasSinUso = (ahora - new Date(n.ultimo_acceso || n.fecha_creacion || ahora).getTime()) / (1000 * 60 * 60 * 24);
+      const baseDecay = { 'ALTA': 0.005, 'MEDIA': 0.01, 'BAJA': 0.02 }[n.confianza] || 0.01;
+      const nuevoDecay = Math.max(0.1, 1.0 - (diasSinUso * baseDecay));
+      
+      // Si decay < 0.3 y confianza BAJA → marcar como OBSOLETO
+      let nuevoEstado = 'ACTIVO';
+      if (nuevoDecay < 0.3 && n.confianza === 'BAJA' && n.aplicado === 0) nuevoEstado = 'OBSOLETO';
+      
+      try {
+        db.run('UPDATE nodos SET decay_score=?, estado=? WHERE id=?', nuevoDecay, nuevoEstado, n.id);
+      } catch(e) {}
+    });
+    
+    if (db.type === 'sqljs' && db.save) db.save();
+    const obsoletos = nodos.filter(n => n.confianza === 'BAJA').length;
+    db.close();
+    return { procesados: nodos.length, obsoletos_potenciales: obsoletos };
+  } catch(e) { return { procesados: 0, error: e.message }; }
+}
+
+// ─── CoALA v3: RECUPERACIÓN HÍBRIDA ──────────────────────────────────────
+// Combina: búsqueda por keyword (BM25-like) + filtro por área + ranking por decay
+// Para búsqueda vectorial real se necesitan embeddings (Voyage AI / local)
+// Sin embeddings usa keyword scoring (ya mejor que solo SQL)
+function buscarHibrido(query, area, topK) {
+  topK = topK || 10;
+  try {
+    const db = initDB();
+    const terms = (query || '').toLowerCase().split(/\s+/).filter(t => t.length > 2);
+    
+    // Búsqueda en nodos procedurales
+    let sqlNodos = `SELECT *, 'procedural' as memoria_tipo FROM nodos WHERE estado='ACTIVO'`;
+    if (area && area !== 'global') sqlNodos += ` AND (area=? OR area='global')`;
+    const nodosAll = area && area !== 'global' 
+      ? db.all(sqlNodos, area) 
+      : db.all(sqlNodos);
+    
+    // Búsqueda en episodios
+    let sqlEpisodios = `SELECT *, 'episodica' as memoria_tipo FROM episodios WHERE relevancia > 0.3`;
+    if (area && area !== 'global') sqlEpisodios += ` AND (area=? OR area='global')`;
+    sqlEpisodios += ' ORDER BY fecha DESC LIMIT 50';
+    const episodiosAll = area && area !== 'global' 
+      ? db.all(sqlEpisodios, area) 
+      : db.all(sqlEpisodios);
+    
+    // Búsqueda en entidades semánticas
+    const entidadesAll = db.all('SELECT *, \'semantica\' as memoria_tipo FROM entidades LIMIT 100');
+    
+    db.close();
+    
+    // Scoring BM25-like por keyword
+    const scoreItem = (item) => {
+      const text = ([item.titulo, item.descripcion, item.contenido, item.accion_tomada, item.razon_resultado, item.nombre]
+        .filter(Boolean).join(' ')).toLowerCase();
+      let score = 0;
+      terms.forEach(term => {
+        const count = (text.match(new RegExp(term, 'g')) || []).length;
+        if (count > 0) score += 1 + Math.log(count); // TF component
+      });
+      // Boost por confianza/relevancia
+      if (item.confianza === 'ALTA') score *= 2.0;
+      else if (item.confianza === 'MEDIA') score *= 1.5;
+      // Boost por decay
+      score *= (item.decay_score || 1.0);
+      // Boost por accesos recientes
+      score += Math.log(1 + (item.accesos_total || item.aplicado || 0)) * 0.3;
+      return score;
+    };
+    
+    // Combinar todos los resultados y rankear
+    const todos = [...nodosAll, ...episodiosAll, ...entidadesAll];
+    const scored = todos
+      .map(item => ({ ...item, _score: scoreItem(item) }))
+      .filter(item => item._score > 0)
+      .sort((a, b) => b._score - a._score)
+      .slice(0, topK);
+    
+    return {
+      resultados: scored,
+      trace: {
+        query, area, topK,
+        nodos_candidatos: nodosAll.length,
+        episodios_candidatos: episodiosAll.length,
+        entidades_candidatas: entidadesAll.length,
+        resultados_finales: scored.length,
+        metodo: 'keyword_hybrid_rrf'
+      }
+    };
+  } catch(e) { return { resultados: [], trace: { error: e.message } }; }
+}
+
+// ─── CoALA v3: STATS EXTENDIDO ────────────────────────────────────────────
+function statsCoala() {
+  const db = initDB();
+  const proc = (db.get('SELECT COUNT(*) as n FROM nodos WHERE estado=\'ACTIVO\'') || {}).n || 0;
+  const episod = (db.get('SELECT COUNT(*) as n FROM episodios') || {}).n || 0;
+  const sinConsolidar = (db.get('SELECT COUNT(*) as n FROM episodios WHERE consolidado=0') || {}).n || 0;
+  const entidades = (db.get('SELECT COUNT(*) as n FROM entidades') || {}).n || 0;
+  const relSem = (db.get('SELECT COUNT(*) as n FROM relaciones_semanticas') || {}).n || 0;
+  const obsoletos = (db.get('SELECT COUNT(*) as n FROM nodos WHERE estado=\'OBSOLETO\'') || {}).n || 0;
+  db.close();
+  
+  console.log('\n  MEMORIA CoALA v3 — Agentic KDD\n');
+  console.log(`  🔧 Procedural (patrones/errores/decisiones): ${proc} activos, ${obsoletos} obsoletos`);
+  console.log(`  📖 Episódica (trayectorias):                 ${episod} total, ${sinConsolidar} sin consolidar`);
+  console.log(`  🧠 Semántica (grafo de entidades):           ${entidades} entidades, ${relSem} relaciones`);
+  console.log('');
+}
+
+// Exportar funciones CoALA nuevas
+const _originalExports = module.exports || {};
+module.exports = {
+  ..._originalExports,
+  registrarEpisodio,
+  consolidarEpisodios,
+  marcarEpisodioConsolidado,
+  registrarEntidad,
+  registrarRelacionSemantica,
+  impactoEntidad,
+  aplicarDecay,
+  buscarHibrido,
+  statsCoala
+};
+
+// Agregar casos al switch CLI
+const _args = process.argv.slice(2);
+if (_args[0] === 'episodio') {
+  try { 
+    const d = JSON.parse(_args[1] || '{}');
+    const id = registrarEpisodio(d);
+    console.log(id ? `Episodio registrado: ${id}` : 'Error');
+  } catch(e) { console.log('JSON inválido'); }
+}
+if (_args[0] === 'consolidar') {
+  const r = consolidarEpisodios(_args[1]);
+  console.log(JSON.stringify(r, null, 2));
+}
+if (_args[0] === 'entidad') {
+  try {
+    const d = JSON.parse(_args[1] || '{}');
+    registrarEntidad(d);
+    console.log('Entidad registrada:', d.nombre);
+  } catch(e) { console.log('JSON inválido'); }
+}
+if (_args[0] === 'impacto') {
+  const r = impactoEntidad(_args[1]);
+  console.log(JSON.stringify(r, null, 2));
+}
+if (_args[0] === 'decay') {
+  const r = aplicarDecay();
+  console.log(`Decay aplicado: ${r.procesados} nodos procesados`);
+}
+if (_args[0] === 'buscar') {
+  const r = buscarHibrido(_args[1], _args[2], parseInt(_args[3]) || 10);
+  console.log(JSON.stringify(r, null, 2));
+}
+if (_args[0] === 'coala') {
+  statsCoala();
+}

package/templates/.agentic/grafo/schema.sql

@@ -1,27 +1,99 @@
--- Agentic KDD — Schema del grafo de conocimiento
+-- Agentic KDD — Schema CoALA v3.0
 -- SQLite — vive en .agentic/memoria.db
+-- Arquitectura de memoria: Working | Episodic | Semantic | Procedural
+-- Inspirado en: CoALA (arXiv:2309.02427), Mem0, agentmemory, MemGPT
 
--- Nodos principales
+-- ─── MEMORIA PROCEDURAL (lo que ya tenía KDD) ─────────────────────────────
+-- Patrones, errores, decisiones — reglas y skills del proyecto
 CREATE TABLE IF NOT EXISTS nodos (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
-  tipo TEXT NOT NULL,        -- error | patron | decision | modulo | tarea
+  tipo TEXT NOT NULL,        -- error | patron | decision | modulo | entidad
   titulo TEXT NOT NULL,
   contenido TEXT,
   area TEXT DEFAULT 'global',
-  confianza TEXT DEFAULT 'BAJA',
-  aplicado INTEGER DEFAULT 0,
-  util INTEGER DEFAULT 0,
-  estado TEXT DEFAULT 'ACTIVO', -- ACTIVO | OBSOLETO | CONSOLIDADO | HISTORICO
+  confianza TEXT DEFAULT 'BAJA',  -- BAJA | MEDIA | ALTA
+  aplicado INTEGER DEFAULT 0,     -- cuántas veces se usó
+  util INTEGER DEFAULT 0,         -- cuántas veces fue útil
+  estado TEXT DEFAULT 'ACTIVO',   -- ACTIVO | OBSOLETO | CONSOLIDADO
+  -- CoALA: decay temporal
+  ultimo_acceso TEXT DEFAULT (datetime('now')),
+  accesos_total INTEGER DEFAULT 0,
+  decay_score REAL DEFAULT 1.0,   -- 1.0=máximo, decae con el tiempo sin uso
+  -- Embeddings para búsqueda semántica (JSON array de floats, opcional)
+  embedding TEXT,
+  embedding_modelo TEXT,          -- qué modelo generó el embedding
   ultima_validacion TEXT DEFAULT (datetime('now')),
   fecha_creacion TEXT DEFAULT (datetime('now')),
   fecha_update TEXT DEFAULT (datetime('now'))
 );
 
--- Relaciones entre nodos
+-- ─── MEMORIA EPISÓDICA ────────────────────────────────────────────────────
+-- Trayectorias completas de lo que se intentó, en qué orden, resultado real
+-- Crítico: NO summarizar al escribir (causa "summarization drift")
+-- Registra la experiencia RAW, la consolidación ocurre después
+CREATE TABLE IF NOT EXISTS episodios (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  episodio_id TEXT NOT NULL UNIQUE,
+  -- Contexto del episodio
+  ciclo_id TEXT,              -- FK a ciclos (si viene de un ciclo aa:)
+  sesion_id TEXT,             -- agrupar episodios de una misma sesión de trabajo
+  tipo TEXT DEFAULT 'accion', -- accion | decision | error | fix | aprendizaje
+  -- Qué pasó exactamente (raw, sin summarizar)
+  descripcion TEXT NOT NULL,  -- descripción detallada de lo que ocurrió
+  intento_num INTEGER DEFAULT 1,   -- era el intento #N de resolver esto
+  contexto_antes TEXT,        -- estado del proyecto antes
+  accion_tomada TEXT,         -- qué se hizo exactamente
+  resultado TEXT,             -- qué pasó (éxito | fallo | parcial)
+  razon_resultado TEXT,       -- por qué pasó lo que pasó
+  archivos_tocados TEXT DEFAULT '[]',  -- JSON array de archivos modificados
+  -- Consolidación a memoria semántica/procedural
+  consolidado INTEGER DEFAULT 0,  -- 0=raw, 1=ya extrajo patrones
+  nodo_generado_id INTEGER,       -- FK a nodos si se consolidó en patrón
+  -- Metadata
+  area TEXT DEFAULT 'global',
+  modulo TEXT DEFAULT 'global',
+  relevancia REAL DEFAULT 1.0,    -- decae con el tiempo
+  fecha TEXT DEFAULT (datetime('now')),
+  FOREIGN KEY (nodo_generado_id) REFERENCES nodos(id)
+);
+
+-- ─── MEMORIA SEMÁNTICA ────────────────────────────────────────────────────
+-- Grafo de entidades del proyecto: módulos, APIs, convenciones, dependencias
+-- Extrae el "mapa" del proyecto para que el agente entienda impacto de cambios
+CREATE TABLE IF NOT EXISTS entidades (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  nombre TEXT NOT NULL UNIQUE,
+  tipo TEXT NOT NULL,    -- modulo | archivo | funcion | api | tabla | variable | concepto
+  descripcion TEXT,
+  area TEXT DEFAULT 'global',
+  -- Qué sabe el sistema sobre esta entidad
+  propiedades TEXT DEFAULT '{}',  -- JSON: {ruta, lenguaje, exporta, importa, etc.}
+  embedding TEXT,                 -- para búsqueda semántica
+  -- Métricas de actividad
+  modificaciones INTEGER DEFAULT 0,  -- cuántas veces fue tocada
+  errores_asociados INTEGER DEFAULT 0,
+  critica INTEGER DEFAULT 0,      -- 1 si es una entidad crítica del sistema
+  fecha_creacion TEXT DEFAULT (datetime('now')),
+  fecha_update TEXT DEFAULT (datetime('now'))
+);
+
+-- Relaciones semánticas entre entidades (grafo de conocimiento del proyecto)
+CREATE TABLE IF NOT EXISTS relaciones_semanticas (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  desde_entidad TEXT NOT NULL,  -- nombre de la entidad origen
+  tipo TEXT NOT NULL,           -- depende_de | importa | usa | extiende | llama | define
+  hacia_entidad TEXT NOT NULL,  -- nombre de la entidad destino
+  peso REAL DEFAULT 1.0,        -- fuerza de la relación
+  descripcion TEXT,             -- por qué existe esta relación
+  fecha TEXT DEFAULT (datetime('now')),
+  UNIQUE(desde_entidad, tipo, hacia_entidad)
+);
+
+-- ─── RELACIONES (memoria procedural — ya existía) ─────────────────────────
 CREATE TABLE IF NOT EXISTS relaciones (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
   desde_id INTEGER NOT NULL,
-  tipo TEXT NOT NULL,  -- ocurrio_en | resuelto_por | origino | aplica_a | relacionado_con
+  tipo TEXT NOT NULL,  -- resuelto_por | origino | aplica_a | relacionado_con | contradice
   hacia_id INTEGER NOT NULL,
   peso REAL DEFAULT 1.0,
   fecha TEXT DEFAULT (datetime('now')),
@@ -29,67 +101,104 @@ CREATE TABLE IF NOT EXISTS relaciones (
   FOREIGN KEY (hacia_id) REFERENCES nodos(id)
 );
 
--- Tabla de ciclos — observabilidad y métricas
+-- ─── CICLOS — observabilidad y métricas ───────────────────────────────────
 CREATE TABLE IF NOT EXISTS ciclos (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
-  ciclo_id TEXT NOT NULL UNIQUE,  -- UUID único por ciclo aa:
+  ciclo_id TEXT NOT NULL UNIQUE,
   tarea TEXT NOT NULL,
+  tipo_tarea TEXT DEFAULT 'feature',  -- feature | bugfix | refactor | docs | audit
   modulo TEXT DEFAULT 'global',
   area TEXT DEFAULT 'global',
-  estado TEXT DEFAULT 'EN_PROGRESO', -- EN_PROGRESO | COMPLETADO | STOP
-  context_guard TEXT DEFAULT 'OK',   -- OK | CONCEPTO_NUEVO | STOP
+  estado TEXT DEFAULT 'EN_PROGRESO',  -- EN_PROGRESO | COMPLETADO | STOP
+  context_guard TEXT DEFAULT 'OK',
   fases_total INTEGER DEFAULT 0,
   fases_completadas INTEGER DEFAULT 0,
-  patrones_aplicados TEXT DEFAULT '[]',  -- JSON array
-  errores_evitados TEXT DEFAULT '[]',    -- JSON array
-  decisiones_usadas TEXT DEFAULT '[]',   -- JSON array
+  patrones_aplicados TEXT DEFAULT '[]',
+  errores_evitados TEXT DEFAULT '[]',
+  decisiones_usadas TEXT DEFAULT '[]',
+  memory_trace TEXT DEFAULT '[]',     -- qué consultó el Analista
   tests_generados INTEGER DEFAULT 0,
   tests_pasando INTEGER DEFAULT 0,
   review_blockers INTEGER DEFAULT 0,
   review_required INTEGER DEFAULT 0,
   stops_count INTEGER DEFAULT 0,
-  sync_grafo INTEGER DEFAULT 0,  -- 1 = OK, 0 = falló
+  sync_grafo INTEGER DEFAULT 0,
   duracion_ms INTEGER DEFAULT 0,
+  snapshot_inicio TEXT,   -- JSON: estado de memoria al inicio
+  snapshot_fin TEXT,      -- JSON: estado de memoria al final
   fecha_inicio TEXT DEFAULT (datetime('now')),
   fecha_fin TEXT
 );
 
--- Tabla de fases — tracing detallado por fase
+-- ─── FASES — tracing detallado ────────────────────────────────────────────
 CREATE TABLE IF NOT EXISTS fases (
   id INTEGER PRIMARY KEY AUTOINCREMENT,
   ciclo_id TEXT NOT NULL,
   fase_num INTEGER NOT NULL,
   fase_nombre TEXT,
-  agente TEXT,   -- front | back | qa | memoria
+  agente TEXT,
   estado TEXT DEFAULT 'EN_PROGRESO',
-  memoria_leida TEXT DEFAULT '[]',   -- qué nodos consultó
-  decision_tomada TEXT,              -- por qué hizo lo que hizo
+  memoria_leida TEXT DEFAULT '[]',
+  decision_tomada TEXT,
   resultado TEXT,
   intentos INTEGER DEFAULT 1,
+  duracion_ms INTEGER DEFAULT 0,
+  tokens_aprox INTEGER DEFAULT 0,
   fecha_inicio TEXT DEFAULT (datetime('now')),
   fecha_fin TEXT,
   FOREIGN KEY (ciclo_id) REFERENCES ciclos(ciclo_id)
 );
 
--- Índices simples
-CREATE INDEX IF NOT EXISTS idx_nodos_tipo ON nodos(tipo);
-CREATE INDEX IF NOT EXISTS idx_nodos_area ON nodos(area);
-CREATE INDEX IF NOT EXISTS idx_nodos_confianza ON nodos(confianza);
-CREATE INDEX IF NOT EXISTS idx_nodos_estado ON nodos(estado);
-CREATE INDEX IF NOT EXISTS idx_relaciones_desde ON relaciones(desde_id);
-CREATE INDEX IF NOT EXISTS idx_relaciones_hacia ON relaciones(hacia_id);
+-- ─── WORKING MEMORY — contexto activo de la sesión ────────────────────────
+-- Buffer temporal que se vacía al inicio de cada sesión nueva
+-- Equivale al "context window estructurado" de CoALA
+CREATE TABLE IF NOT EXISTS working_memory (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  sesion_id TEXT NOT NULL,
+  tipo TEXT NOT NULL,       -- observacion | razonamiento | plan | resultado
+  contenido TEXT NOT NULL,
+  relevancia REAL DEFAULT 1.0,
+  expirado INTEGER DEFAULT 0,  -- 1 si ya fue consolidado o expiró
+  fecha TEXT DEFAULT (datetime('now'))
+);
 
--- Índices compuestos — velocidad para queries del Analista
+-- ─── ÍNDICES OPTIMIZADOS ──────────────────────────────────────────────────
+-- Nodos (procedural)
+CREATE UNIQUE INDEX IF NOT EXISTS idx_nodos_unique ON nodos(tipo, titulo);
 CREATE INDEX IF NOT EXISTS idx_nodos_area_tipo ON nodos(area, tipo);
 CREATE INDEX IF NOT EXISTS idx_nodos_area_confianza ON nodos(area, confianza);
 CREATE INDEX IF NOT EXISTS idx_nodos_tipo_confianza ON nodos(tipo, confianza);
 CREATE INDEX IF NOT EXISTS idx_nodos_tipo_estado ON nodos(tipo, estado);
 CREATE INDEX IF NOT EXISTS idx_nodos_area_tipo_estado ON nodos(area, tipo, estado);
 CREATE INDEX IF NOT EXISTS idx_nodos_confianza_aplicado ON nodos(confianza, aplicado);
+CREATE INDEX IF NOT EXISTS idx_nodos_decay ON nodos(decay_score, confianza);
+
+-- Episódica
+CREATE INDEX IF NOT EXISTS idx_episodios_ciclo ON episodios(ciclo_id);
+CREATE INDEX IF NOT EXISTS idx_episodios_sesion ON episodios(sesion_id);
+CREATE INDEX IF NOT EXISTS idx_episodios_tipo ON episodios(tipo);
+CREATE INDEX IF NOT EXISTS idx_episodios_area ON episodios(area);
+CREATE INDEX IF NOT EXISTS idx_episodios_consolidado ON episodios(consolidado);
+CREATE INDEX IF NOT EXISTS idx_episodios_fecha ON episodios(fecha);
+
+-- Semántica
+CREATE INDEX IF NOT EXISTS idx_entidades_tipo ON entidades(tipo);
+CREATE INDEX IF NOT EXISTS idx_entidades_area ON entidades(area);
+CREATE INDEX IF NOT EXISTS idx_rel_semanticas_desde ON relaciones_semanticas(desde_entidad);
+CREATE INDEX IF NOT EXISTS idx_rel_semanticas_hacia ON relaciones_semanticas(hacia_entidad);
 
--- Índices para ciclos y fases
+-- Ciclos y fases
+CREATE UNIQUE INDEX IF NOT EXISTS idx_ciclos_unique ON ciclos(ciclo_id);
 CREATE INDEX IF NOT EXISTS idx_ciclos_estado ON ciclos(estado);
 CREATE INDEX IF NOT EXISTS idx_ciclos_modulo ON ciclos(modulo);
 CREATE INDEX IF NOT EXISTS idx_ciclos_fecha ON ciclos(fecha_inicio);
 CREATE INDEX IF NOT EXISTS idx_fases_ciclo ON fases(ciclo_id);
 CREATE INDEX IF NOT EXISTS idx_fases_agente ON fases(agente);
+
+-- Working memory
+CREATE INDEX IF NOT EXISTS idx_working_sesion ON working_memory(sesion_id);
+CREATE INDEX IF NOT EXISTS idx_working_expirado ON working_memory(expirado);
+
+-- Relaciones
+CREATE UNIQUE INDEX IF NOT EXISTS idx_rel_unique ON relaciones(desde_id, tipo, hacia_id);
+CREATE UNIQUE INDEX IF NOT EXISTS idx_rel_sem_unique ON relaciones_semanticas(desde_entidad, tipo, hacia_entidad);