agentic-kdd 2.0.7 → 2.1.1

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

@@ -0,0 +1,524 @@
+#!/usr/bin/env node
+'use strict';
+
+const path = require('path');
+const fs = require('fs');
+const crypto = require('crypto');
+
+// ─── DB ADAPTER — better-sqlite3 nativo o sql.js puro JS ─────────────────────
+// Intenta better-sqlite3 (rápido, nativo). Si falla, usa sql.js (puro JS, sin compilar).
+// El usuario no hace nada — funciona en cualquier Windows/Mac/Linux automáticamente.
+
+let dbAdapter = null; // 'better-sqlite3' | 'sqljs'
+
+function getDB(dbPath) {
+  // Intentar better-sqlite3 primero
+  if (dbAdapter !== 'sqljs') {
+    try {
+      const BS3 = require('better-sqlite3');
+      const db = new BS3(dbPath);
+      db.pragma('journal_mode = WAL');
+      db.pragma('synchronous = NORMAL');
+      db.pragma('cache_size = -64000');
+      db.pragma('temp_store = MEMORY');
+      dbAdapter = 'better-sqlite3';
+      return { db, type: 'better-sqlite3' };
+    } catch(e) {
+      dbAdapter = 'sqljs';
+    }
+  }
+
+  // Fallback: sql.js (puro JavaScript, sin compilación, funciona en cualquier Windows)
+  try {
+    const initSqlJs = require('sql.js');
+    // sql.js es async — usamos sync wrapper
+    const SQL = require('sql.js/dist/sql-wasm.js');
+    let buffer = null;
+    if (fs.existsSync(dbPath)) {
+      buffer = fs.readFileSync(dbPath);
+    }
+    const db = new SQL.Database(buffer);
+    dbAdapter = 'sqljs';
+    return { db, type: 'sqljs', path: dbPath };
+  } catch(e) {
+    // Si ninguno está disponible, instalar sql.js automáticamente
+    console.log('  Instalando dependencias del grafo...');
+    try {
+      require('child_process').execSync('npm install sql.js --save', {
+        stdio: 'pipe', cwd: path.join(__dirname, '..', '..')
+      });
+      const SQL = require('sql.js/dist/sql-wasm.js');
+      let buffer = null;
+      if (fs.existsSync(dbPath)) buffer = fs.readFileSync(dbPath);
+      const db = new SQL.Database(buffer);
+      dbAdapter = 'sqljs';
+      return { db, type: 'sqljs', path: dbPath };
+    } catch(e2) {
+      throw new Error('No se pudo inicializar el grafo SQLite. Corre: npm install sql.js');
+    }
+  }
+}
+
+// Wrapper unificado que abstrae las diferencias entre better-sqlite3 y sql.js
+function createAdapter(dbPath) {
+  const { db, type, path: sqlPath } = getDB(dbPath);
+
+  if (type === 'better-sqlite3') {
+    // API nativa — synchronous, más rápida
+    return {
+      exec: (sql) => db.exec(sql),
+      prepare: (sql) => db.prepare(sql),
+      all: (sql, ...params) => db.prepare(sql).all(...params),
+      get: (sql, ...params) => db.prepare(sql).get(...params),
+      run: (sql, ...params) => db.prepare(sql).run(...params),
+      transaction: (fn) => db.transaction(fn),
+      pragma: (p) => db.pragma(p),
+      close: () => db.close(),
+      type: 'better-sqlite3'
+    };
+  } else {
+    // sql.js API — puro JS, necesita guardar el archivo manualmente
+    const saveDB = () => {
+      try {
+        const data = db.export();
+        fs.writeFileSync(sqlPath, Buffer.from(data));
+      } catch(e) {}
+    };
+
+    const runSQL = (sql, params) => {
+      try { db.run(sql, params || []); } catch(e) {}
+    };
+
+    const execSQL = (sql) => {
+      try { db.exec(sql); } catch(e) {}
+    };
+
+    const allSQL = (sql, ...params) => {
+      try {
+        const stmt = db.prepare(sql);
+        const rows = [];
+        const flatParams = params.flat();
+        if (flatParams.length) stmt.bind(flatParams);
+        while (stmt.step()) {
+          const row = stmt.getAsObject();
+          rows.push(row);
+        }
+        stmt.free();
+        return rows;
+      } catch(e) { return []; }
+    };
+
+    const getSQL = (sql, ...params) => {
+      const rows = allSQL(sql, ...params);
+      return rows[0] || null;
+    };
+
+    return {
+      exec: execSQL,
+      all: allSQL,
+      get: getSQL,
+      run: (sql, ...params) => { runSQL(sql, params.flat()); saveDB(); },
+      transaction: (fn) => (...args) => { fn(...args); saveDB(); },
+      pragma: () => {}, // no-op en sql.js
+      close: () => saveDB(),
+      type: 'sqljs',
+      save: saveDB
+    };
+  }
+}
+
+const ROOT        = path.join(__dirname, '..', '..');
+const DB_PATH     = path.join(ROOT, '.agentic', 'memoria.db');
+const SCHEMA_PATH = path.join(__dirname, 'schema.sql');
+const MEMORIA_PATH= path.join(ROOT, '.agentic', 'memoria');
+
+// ─── INIT ──────────────────────────────────────────────────────────────────────
+function initDB() {
+  const adapter = createAdapter(DB_PATH);
+  const schema  = fs.readFileSync(SCHEMA_PATH, 'utf8');
+  // Ejecutar schema línea por línea para compatibilidad con sql.js
+  schema.split(';').map(s => s.trim()).filter(s => s && !s.startsWith('--')).forEach(s => {
+    try { adapter.exec(s + ';'); } catch(e) {}
+  });
+  migrateDB(adapter);
+  return adapter;
+}
+
+function migrateDB(db) {
+  const alteraciones = [
+    "ALTER TABLE nodos ADD COLUMN ultima_validacion TEXT DEFAULT (datetime('now'))",
+    "ALTER TABLE ciclos ADD COLUMN tipo_tarea TEXT DEFAULT 'feature'",
+    "ALTER TABLE ciclos ADD COLUMN memory_trace TEXT DEFAULT '[]'",
+    "ALTER TABLE ciclos ADD COLUMN snapshot_inicio TEXT",
+    "ALTER TABLE ciclos ADD COLUMN snapshot_fin TEXT",
+    "ALTER TABLE fases ADD COLUMN duracion_ms INTEGER DEFAULT 0",
+    "ALTER TABLE fases ADD COLUMN tokens_aprox INTEGER DEFAULT 0",
+  ];
+  alteraciones.forEach(sql => { try { db.exec(sql); } catch(e) {} });
+
+  const indices = [
+    "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_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 UNIQUE INDEX IF NOT EXISTS idx_rel_unique ON relaciones(desde_id, tipo, hacia_id)",
+  ];
+  indices.forEach(sql => { try { db.exec(sql); } catch(e) {} });
+}
+
+// ─── SNAPSHOT ─────────────────────────────────────────────────────────────────
+function snapshotMemoria(db) {
+  try {
+    const snap = { fecha: new Date().toISOString(), totales: {}, por_tipo: {}, alta_rules: [] };
+    snap.totales.total    = (db.get('SELECT COUNT(*) as n FROM nodos') || {}).n || 0;
+    snap.totales.alta     = (db.get("SELECT COUNT(*) as n FROM nodos WHERE confianza='ALTA'") || {}).n || 0;
+    snap.totales.media    = (db.get("SELECT COUNT(*) as n FROM nodos WHERE confianza='MEDIA'") || {}).n || 0;
+    snap.totales.activos  = (db.get("SELECT COUNT(*) as n FROM nodos WHERE estado='ACTIVO'") || {}).n || 0;
+    snap.totales.obsoletos= (db.get("SELECT COUNT(*) as n FROM nodos WHERE estado='OBSOLETO'") || {}).n || 0;
+    snap.alta_rules = db.all("SELECT titulo, tipo, area FROM nodos WHERE confianza='ALTA' AND estado='ACTIVO'");
+    const porTipo = db.all('SELECT tipo, COUNT(*) as n FROM nodos GROUP BY tipo');
+    porTipo.forEach(r => snap.por_tipo[r.tipo] = r.n);
+    return snap;
+  } catch(e) { return null; }
+}
+
+// ─── PARSEAR ENTRADAS ─────────────────────────────────────────────────────────
+function parsearEntradas(contenido, tipo) {
+  const entradas = [];
+  const secciones = contenido.split(/^## /m).filter(s => {
+    const t = s.trim();
+    return t && !t.startsWith('<!--') && !t.startsWith('Cómo') &&
+      !t.startsWith('Formato') && !t.startsWith('Registro') &&
+      !t.startsWith('Patrones') && t.length > 10;
+  });
+  for (const sec of secciones) {
+    const lineas = sec.split('\n');
+    const titulo = lineas[0].trim().replace(/^\[.*?\]\s*/, '').trim();
+    if (!titulo || titulo.length < 5) continue;
+    const e = { tipo, titulo, contenido: sec, area: 'global', confianza: 'BAJA',
+      aplicado: 0, util: 0, estado: 'ACTIVO', ultima_validacion: new Date().toISOString() };
+    for (const l of lineas) {
+      if (l.startsWith('Área:') || l.startsWith('Area:'))
+        e.area = l.split(':')[1]?.trim() || 'global';
+      if (l.startsWith('Confianza:'))
+        e.confianza = l.split(':')[1]?.trim() || 'BAJA';
+      if (l.startsWith('Aplicado:'))
+        e.aplicado = parseInt(l.split(':')[1]?.trim()) || 0;
+      if (l.startsWith('Útil:') || l.startsWith('Util:'))
+        e.util = parseInt(l.split(':')[1]?.trim()) || 0;
+      if (l.startsWith('Estado:'))
+        e.estado = l.split(':')[1]?.trim().split(' ')[0] || 'ACTIVO';
+      if (l.startsWith('Última validación:') || l.startsWith('Ultima validacion:'))
+        e.ultima_validacion = l.split(':').slice(1).join(':').trim();
+    }
+    entradas.push(e);
+  }
+  return entradas;
+}
+
+// ─── SINCRONIZAR ──────────────────────────────────────────────────────────────
+function sincronizar() {
+  const db = initDB();
+  const archivos = [
+    { file: 'errores.md', tipo: 'error' },
+    { file: 'patrones.md', tipo: 'patron' },
+    { file: 'decisiones.md', tipo: 'decision' }
+  ];
+  let total = 0, nuevos = 0, actualizados = 0;
+
+  for (const { file, tipo } of archivos) {
+    const fp = path.join(MEMORIA_PATH, file);
+    if (!fs.existsSync(fp)) continue;
+    const entradas = parsearEntradas(fs.readFileSync(fp, 'utf8'), tipo);
+    for (const e of entradas) {
+      const ex = db.get('SELECT id FROM nodos WHERE tipo=? AND titulo=?', e.tipo, e.titulo);
+      if (ex) {
+        db.run('UPDATE nodos SET contenido=?,area=?,confianza=?,aplicado=?,util=?,estado=?,ultima_validacion=?,fecha_update=datetime(\'now\') WHERE tipo=? AND titulo=?',
+          e.contenido, e.area, e.confianza, e.aplicado, e.util, e.estado, e.ultima_validacion, e.tipo, e.titulo);
+        actualizados++;
+      } else {
+        db.run("INSERT INTO nodos (tipo,titulo,contenido,area,confianza,aplicado,util,estado,ultima_validacion,fecha_update) VALUES (?,?,?,?,?,?,?,?,?,datetime('now'))",
+          e.tipo, e.titulo, e.contenido, e.area, e.confianza, e.aplicado, e.util, e.estado, e.ultima_validacion);
+        nuevos++;
+      }
+      total++;
+    }
+  }
+  if (db.type === 'sqljs' && db.save) db.save();
+  detectarRelaciones(db);
+  db.close();
+  console.log(`\n  Grafo sincronizado — ${total} nodos (${nuevos} nuevos, ${actualizados} actualizados)`);
+  console.log(`  Motor: ${dbAdapter === 'better-sqlite3' ? 'nativo (<5ms)' : 'sql.js (<20ms)'}\n`);
+}
+
+// ─── RELACIONES ────────────────────────────────────────────────────────────────
+function detectarRelaciones(db) {
+  const nodos = db.all('SELECT * FROM nodos');
+  for (const n of nodos) for (const o of nodos) {
+    if (n.id === o.id) continue;
+    if (n.tipo==='error'  && o.tipo==='patron'   && (n.area===o.area||o.area==='global'))
+      try { db.run('INSERT OR IGNORE INTO relaciones (desde_id,tipo,hacia_id,peso) VALUES (?,?,?,?)', n.id,'resuelto_por',o.id,1.0); } catch(e) {}
+    if (n.tipo==='patron' && o.tipo==='decision' && (n.area===o.area||o.area==='global'))
+      try { db.run('INSERT OR IGNORE INTO relaciones (desde_id,tipo,hacia_id,peso) VALUES (?,?,?,?)', n.id,'origino',o.id,0.8); } catch(e) {}
+    if (n.area===o.area && n.area!=='global' && n.id<o.id)
+      try { db.run('INSERT OR IGNORE INTO relaciones (desde_id,tipo,hacia_id,peso) VALUES (?,?,?,?)', n.id,'relacionado_con',o.id,0.5); } catch(e) {}
+    if (n.confianza==='ALTA' && o.confianza==='ALTA' && n.area===o.area && n.id<o.id)
+      try { db.run('INSERT OR IGNORE INTO relaciones (desde_id,tipo,hacia_id,peso) VALUES (?,?,?,?)', n.id,'aplica_a',o.id,1.5); } catch(e) {}
+  }
+  if (db.type === 'sqljs' && db.save) db.save();
+}
+
+// ─── CONSULTAR ────────────────────────────────────────────────────────────────
+function consultar(area, tipo) {
+  const db = initDB();
+  const trace = { area, tipo, timestamp: new Date().toISOString(), nodos_retornados: 0, titulos: [] };
+  let sql = "SELECT * FROM nodos WHERE estado='ACTIVO'";
+  const params = [];
+  if (area && area !== 'global') { sql += " AND (area=? OR area='global')"; params.push(area); }
+  if (tipo) { sql += " AND tipo=?"; params.push(tipo); }
+  sql += " ORDER BY CASE confianza WHEN 'ALTA' THEN 0 WHEN 'MEDIA' THEN 1 ELSE 2 END, util DESC, aplicado DESC";
+  const resultados = db.all(sql, ...params);
+  trace.nodos_retornados = resultados.length;
+  trace.titulos = resultados.slice(0,5).map(r => r.titulo);
+  db.close();
+  return { resultados, trace };
+}
+
+// ─── STATS ────────────────────────────────────────────────────────────────────
+function stats() {
+  const db = initDB();
+  const totalNodos = (db.get('SELECT COUNT(*) as n FROM nodos') || {}).n || 0;
+  const totalRels  = (db.get('SELECT COUNT(*) as n FROM relaciones') || {}).n || 0;
+  const porTipo    = db.all('SELECT tipo, COUNT(*) as n FROM nodos GROUP BY tipo');
+  const porConf    = db.all('SELECT confianza, COUNT(*) as n FROM nodos GROUP BY confianza');
+  const altas      = db.all("SELECT titulo,tipo,area FROM nodos WHERE confianza='ALTA' AND estado='ACTIVO'");
+  let cicloStats   = null;
+  try {
+    const total = (db.get('SELECT COUNT(*) as n FROM ciclos') || {}).n || 0;
+    if (total > 0) {
+      const comp  = (db.get("SELECT COUNT(*) as n FROM ciclos WHERE estado='COMPLETADO'") || {}).n || 0;
+      const stops = (db.get("SELECT COUNT(*) as n FROM ciclos WHERE estado='STOP'") || {}).n || 0;
+      cicloStats = { total, comp, stops, goal: Math.round(comp/total*100) };
+    }
+  } catch(e) {}
+  db.close();
+
+  console.log('\n  GRAFO DE CONOCIMIENTO — Agentic KDD\n');
+  console.log(`  Motor: ${dbAdapter === 'better-sqlite3' ? 'better-sqlite3 nativo' : 'sql.js (compatible Windows)'}`);
+  console.log(`  Total nodos: ${totalNodos} | Relaciones: ${totalRels}`);
+  if (porTipo.length)  { console.log('\n  Por tipo:');      porTipo.forEach(r => console.log(`    ${r.tipo}: ${r.n}`)); }
+  if (porConf.length)  { console.log('\n  Por confianza:'); porConf.forEach(r => console.log(`    ${r.confianza}: ${r.n}`)); }
+  if (altas.length)    { console.log('\n  Reglas ALTA (permanentes):'); altas.forEach(r => console.log(`    [${r.tipo}] ${r.titulo} (${r.area})`)); }
+  if (cicloStats)      { console.log(`\n  Ciclos: ${cicloStats.total} | Completados: ${cicloStats.comp} | STOPs: ${cicloStats.stops} | Goal Attainment: ${cicloStats.goal}%`); }
+  if (totalNodos === 0) console.log('\n  Sin datos — usa aa: para empezar.');
+  console.log('');
+}
+
+// ─── MÉTRICAS ─────────────────────────────────────────────────────────────────
+function metricas() {
+  try {
+    const db = initDB();
+    const ciclos = db.all('SELECT * FROM ciclos ORDER BY fecha_inicio DESC');
+    if (!ciclos.length) { db.close(); return { total: 0, mensaje: 'Sin ciclos aun' }; }
+    const total       = ciclos.length;
+    const completados = ciclos.filter(c => c.estado==='COMPLETADO').length;
+    const stops       = ciclos.filter(c => c.estado==='STOP').length;
+    const goal        = Math.round(completados/total*100);
+    const autonomy    = Math.round((total-stops)/total*100);
+    const totalFases  = ciclos.reduce((s,c)=>s+(c.fases_total||0),0);
+    const fasesOK     = ciclos.reduce((s,c)=>s+(c.fases_completadas||0),0);
+    const handoff     = totalFases>0?Math.round(fasesOK/totalFases*100):0;
+    const blockers    = ciclos.reduce((s,c)=>s+(c.review_blockers||0),0);
+    const drift       = (blockers/total).toFixed(2);
+    const guardrails  = ciclos.filter(c=>c.context_guard==='STOP').length;
+    let pats=0, errs=0;
+    ciclos.forEach(c=>{
+      try{pats+=JSON.parse(c.patrones_aplicados||'[]').length;}catch(e){}
+      try{errs+=JSON.parse(c.errores_evitados||'[]').length;}catch(e){}
+    });
+    const tGen = ciclos.reduce((s,c)=>s+(c.tests_generados||0),0);
+    const tOK  = ciclos.reduce((s,c)=>s+(c.tests_pasando||0),0);
+    // Éxito por tipo de tarea
+    const tipoMap = {};
+    ciclos.forEach(c=>{
+      const t = c.tipo_tarea||'feature';
+      if(!tipoMap[t]) tipoMap[t]={total:0,ok:0};
+      tipoMap[t].total++;
+      if(c.estado==='COMPLETADO') tipoMap[t].ok++;
+    });
+    const exito_por_tipo = Object.entries(tipoMap).map(([tipo,v])=>({
+      tipo, total:v.total, ok:v.ok, rate:Math.round(v.ok/v.total*100)
+    }));
+    // Evolución de memoria
+    let evolucion = null;
+    const conSnap = ciclos.filter(c=>c.snapshot_fin);
+    if (conSnap.length>=2) {
+      try {
+        const p = JSON.parse(conSnap[conSnap.length-1].snapshot_fin);
+        const u = JSON.parse(conSnap[0].snapshot_fin);
+        evolucion = {
+          nodos_inicio: p.totales?.total||0, nodos_ahora: u.totales?.total||0,
+          alta_inicio: p.totales?.alta||0,   alta_ahora:  u.totales?.alta||0,
+          crecimiento: (u.totales?.total||0)-(p.totales?.total||0)
+        };
+      } catch(e) {}
+    }
+    db.close();
+    return {
+      total, completados, stops,
+      goal_attainment: goal, autonomy_ratio: autonomy,
+      handoff_integrity: handoff, drift_index: drift,
+      guardrail_violations: guardrails,
+      patrones_aplicados: pats, errores_evitados: errs,
+      test_rate: tGen>0?Math.round(tOK/tGen*100):0,
+      tests_generados: tGen, tests_pasando: tOK,
+      exito_por_tipo, evolucion_memoria: evolucion,
+      ciclos_recientes: ciclos.slice(0,15),
+      motor: dbAdapter
+    };
+  } catch(e) { return { total:0, error: e.message }; }
+}
+
+// ─── REGISTRAR CICLO ──────────────────────────────────────────────────────────
+function registrarCiclo(datos) {
+  try {
+    const db = initDB();
+    const ciclo_id = crypto.randomUUID
+      ? crypto.randomUUID()
+      : Date.now().toString(36)+Math.random().toString(36).slice(2);
+    const snap = snapshotMemoria(db);
+    db.run(`INSERT INTO ciclos (ciclo_id,tarea,tipo_tarea,modulo,area,estado,context_guard,
+      fases_total,fases_completadas,patrones_aplicados,errores_evitados,decisiones_usadas,
+      memory_trace,tests_generados,tests_pasando,review_blockers,review_required,stops_count,
+      sync_grafo,duracion_ms,snapshot_inicio,snapshot_fin,fecha_fin)
+      VALUES (?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,datetime('now'))`,
+      ciclo_id,
+      datos.tarea||'',
+      datos.tipo_tarea||'feature',
+      datos.modulo||'global',
+      datos.area||'global',
+      datos.estado||'COMPLETADO',
+      datos.context_guard||'OK',
+      datos.fases_total||0,
+      datos.fases_completadas||0,
+      JSON.stringify(datos.patrones_aplicados||[]),
+      JSON.stringify(datos.errores_evitados||[]),
+      JSON.stringify(datos.decisiones_usadas||[]),
+      JSON.stringify(datos.memory_trace||[]),
+      datos.tests_generados||0,
+      datos.tests_pasando||0,
+      datos.review_blockers||0,
+      datos.review_required||0,
+      datos.stops_count||0,
+      datos.sync_grafo?1:0,
+      datos.duracion_ms||0,
+      snap?JSON.stringify(snap):null,
+      snap?JSON.stringify(snap):null
+    );
+    if (datos.fases && Array.isArray(datos.fases)) {
+      datos.fases.forEach(f => {
+        try {
+          db.run(`INSERT OR IGNORE INTO fases (ciclo_id,fase_num,fase_nombre,agente,estado,
+            memoria_leida,decision_tomada,resultado,intentos,duracion_ms,fecha_fin)
+            VALUES (?,?,?,?,?,?,?,?,?,?,datetime('now'))`,
+            ciclo_id,f.num||0,f.nombre||'',f.agente||'',f.estado||'COMPLETADO',
+            JSON.stringify(f.memoria_leida||[]),f.decision||'',f.resultado||'',
+            f.intentos||1,f.duracion_ms||0);
+        } catch(e) {}
+      });
+    }
+    if (db.type==='sqljs' && db.save) db.save();
+    db.close();
+    return ciclo_id;
+  } catch(e) { return null; }
+}
+
+// ─── EMBEDDINGS SEMÁNTICOS (opcional) ─────────────────────────────────────────
+async function buscarSemantico(query, topK) {
+  topK = topK||5;
+  const apiKey = process.env.ANTHROPIC_API_KEY;
+  if (!apiKey) {
+    const {resultados} = consultar(query, null);
+    return resultados.slice(0,topK);
+  }
+  try {
+    const queryEmb = await getEmbedding(query, apiKey);
+    if (!queryEmb) { const {resultados}=consultar(query,null); return resultados.slice(0,topK); }
+    const db = initDB();
+    const nodos = db.all("SELECT * FROM nodos WHERE estado='ACTIVO'");
+    db.close();
+    const scored = [];
+    for (const n of nodos) {
+      const txt = `${n.titulo} ${n.area} ${(n.contenido||'').slice(0,400)}`;
+      const emb  = await getEmbedding(txt, apiKey);
+      if (emb) scored.push({...n, _score: cosineSim(queryEmb,emb)});
+    }
+    return scored.sort((a,b)=>b._score-a._score).slice(0,topK);
+  } catch(e) {
+    const {resultados} = consultar(query,null);
+    return resultados.slice(0,topK);
+  }
+}
+
+async function getEmbedding(text, apiKey) {
+  return new Promise(resolve => {
+    try {
+      const https = require('https');
+      const body = JSON.stringify({model:'voyage-3',input:[text],input_type:'document'});
+      const req = https.request({
+        hostname:'api.voyageai.com',path:'/v1/embeddings',method:'POST',
+        headers:{'Authorization':`Bearer ${apiKey}`,'Content-Type':'application/json','Content-Length':Buffer.byteLength(body)}
+      }, res => {
+        let d=''; res.on('data',c=>d+=c);
+        res.on('end',()=>{ try{resolve(JSON.parse(d).data?.[0]?.embedding||null);}catch(e){resolve(null);} });
+      });
+      req.on('error',()=>resolve(null));
+      req.setTimeout(5000,()=>{req.destroy();resolve(null);});
+      req.write(body); req.end();
+    } catch(e) { resolve(null); }
+  });
+}
+
+function cosineSim(a,b) {
+  if (!a||!b||a.length!==b.length) return 0;
+  let dot=0,na=0,nb=0;
+  for(let i=0;i<a.length;i++){dot+=a[i]*b[i];na+=a[i]*a[i];nb+=b[i]*b[i];}
+  return dot/(Math.sqrt(na)*Math.sqrt(nb)||1);
+}
+
+// ─── CLI ──────────────────────────────────────────────────────────────────────
+const cmd  = process.argv[2]||'sync';
+const arg1 = process.argv[3];
+const arg2 = process.argv[4];
+
+switch(cmd) {
+  case 'sync':     sincronizar(); break;
+  case 'query':
+    const {resultados,trace} = consultar(arg1,arg2);
+    console.log(JSON.stringify({resultados,trace},null,2)); break;
+  case 'stats':    stats(); break;
+  case 'metricas': console.log(JSON.stringify(metricas(),null,2)); break;
+  case 'ciclo':
+    try {
+      const d = JSON.parse(arg1||'{}');
+      const id = registrarCiclo(d);
+      console.log(id?`Ciclo registrado: ${id}`:'Error al registrar');
+    } catch(e) { console.log('JSON invalido'); } break;
+  case 'semantico':
+    if (!arg1) { console.log('Uso: node grafo.cjs semantico "query" [topK]'); break; }
+    buscarSemantico(arg1,parseInt(arg2)||5).then(r=>console.log(JSON.stringify(r,null,2)));
+    break;
+  case 'snapshot':
+    const db2=initDB(); console.log(JSON.stringify(snapshotMemoria(db2),null,2)); db2.close(); break;
+  default:
+    console.log('Uso: node grafo.cjs [sync|query|stats|metricas|ciclo|semantico|snapshot]');
+}
+
+module.exports = { sincronizar, consultar, stats, metricas, registrarCiclo, buscarSemantico, snapshotMemoria };

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

@@ -0,0 +1,95 @@
+-- Agentic KDD — Schema del grafo de conocimiento
+-- SQLite — vive en .agentic/memoria.db
+
+-- Nodos principales
+CREATE TABLE IF NOT EXISTS nodos (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  tipo TEXT NOT NULL,        -- error | patron | decision | modulo | tarea
+  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
+  ultima_validacion TEXT DEFAULT (datetime('now')),
+  fecha_creacion TEXT DEFAULT (datetime('now')),
+  fecha_update TEXT DEFAULT (datetime('now'))
+);
+
+-- Relaciones entre nodos
+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
+  hacia_id INTEGER NOT NULL,
+  peso REAL DEFAULT 1.0,
+  fecha TEXT DEFAULT (datetime('now')),
+  FOREIGN KEY (desde_id) REFERENCES nodos(id),
+  FOREIGN KEY (hacia_id) REFERENCES nodos(id)
+);
+
+-- Tabla de 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:
+  tarea TEXT NOT NULL,
+  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
+  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
+  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ó
+  duracion_ms INTEGER DEFAULT 0,
+  fecha_inicio TEXT DEFAULT (datetime('now')),
+  fecha_fin TEXT
+);
+
+-- Tabla de fases — tracing detallado por fase
+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
+  estado TEXT DEFAULT 'EN_PROGRESO',
+  memoria_leida TEXT DEFAULT '[]',   -- qué nodos consultó
+  decision_tomada TEXT,              -- por qué hizo lo que hizo
+  resultado TEXT,
+  intentos INTEGER DEFAULT 1,
+  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);
+
+-- Índices compuestos — velocidad para queries del Analista
+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);
+
+-- Índices para ciclos y fases
+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);