agentic-kdd 3.5.5 → 3.5.7

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

@@ -212,6 +212,52 @@ function migrateDB(db) {
     "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) {} });
+
+  // v2.2 — nuevas tablas (seguro llamar múltiples veces)
+  const tablasV22 = [
+    `CREATE TABLE IF NOT EXISTS git_context_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      sesion_id TEXT NOT NULL,
+      rama TEXT, commit_hash TEXT,
+      archivos_modificados TEXT DEFAULT '[]',
+      riesgos_detectados TEXT DEFAULT '[]',
+      predicciones TEXT DEFAULT '[]',
+      tiene_riesgos_altos INTEGER DEFAULT 0,
+      fecha TEXT DEFAULT (datetime('now'))
+    )`,
+    `CREATE TABLE IF NOT EXISTS cicd_reports (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      episodio_id TEXT, plataforma TEXT DEFAULT 'github',
+      workflow TEXT, rama TEXT, commit_hash TEXT, actor TEXT, repo TEXT,
+      run_id TEXT, run_url TEXT,
+      tests_pasando INTEGER DEFAULT 0, tests_fallando INTEGER DEFAULT 0,
+      archivos_tocados TEXT DEFAULT '[]', errores_tests TEXT DEFAULT '[]',
+      es_exito INTEGER DEFAULT 0,
+      fecha TEXT DEFAULT (datetime('now'))
+    )`,
+    `CREATE TABLE IF NOT EXISTS prediction_log (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      tarea TEXT, modulo TEXT, archivos TEXT DEFAULT '[]',
+      nivel_predicho TEXT, alertas TEXT DEFAULT '[]', precondiciones TEXT DEFAULT '[]',
+      fue_correcto INTEGER, ciclo_id TEXT,
+      fecha TEXT DEFAULT (datetime('now'))
+    )`,
+  ];
+  tablasV22.forEach(sql => { try { db.exec(sql); } catch(e) {} });
+
+  // v2.2 — embedding en episodios
+  const migracionesV22 = [
+    "ALTER TABLE episodios ADD COLUMN embedding TEXT",
+  ];
+  migracionesV22.forEach(sql => { try { db.exec(sql); } catch(e) {} });
+
+  // v2.2 — índices nuevas tablas
+  const indicesV22 = [
+    "CREATE INDEX IF NOT EXISTS idx_git_context_fecha ON git_context_log(fecha)",
+    "CREATE INDEX IF NOT EXISTS idx_cicd_rama ON cicd_reports(rama)",
+    "CREATE INDEX IF NOT EXISTS idx_prediction_fecha ON prediction_log(fecha)",
+  ];
+  indicesV22.forEach(sql => { try { db.exec(sql); } catch(e) {} });
 }
 
 // ─── SNAPSHOT ─────────────────────────────────────────────────────────────────
@@ -1323,9 +1369,657 @@ if (_args[0] === 'decay') {
   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));
+  // v2.2: búsqueda híbrida con embeddings si disponibles
+  const embMod = getEmbeddingsModuleGrafo();
+  if (embMod && embMod.isAvailable()) {
+    buscarHibridoConEmbeddings(_args[1], _args[2], parseInt(_args[3]) || 10)
+      .then(r => console.log(JSON.stringify({ resultados: r, trace: { metodo: 'vector_hybrid_rrf' } }, null, 2)));
+  } else {
+    const r = buscarHibrido(_args[1], _args[2], parseInt(_args[3]) || 10);
+    console.log(JSON.stringify(r, null, 2));
+  }
 }
 if (_args[0] === 'coala') {
   statsCoala();
 }
+
+// ─── v2.2: Nuevos comandos CLI ────────────────────────────────────────────────
+
+if (_args[0] === 'git-context') {
+  const gitMod = getGitContextModuleGrafo();
+  if (!gitMod) { console.log('  git-context module not available (akdd update)'); process.exit(0); }
+  const db = initDB();
+  const resultado = gitMod.analizarGitContext(ROOT, db);
+  if (resultado.disponible) {
+    const { contexto } = resultado;
+    // Guardar en working_memory
+    const sesionId = `git-${Date.now()}`;
+    try {
+      db.run('UPDATE working_memory SET expirado=1 WHERE expirado=0');
+      db.run(
+        `INSERT INTO working_memory (sesion_id, tipo, contenido, relevancia) VALUES (?,?,?,?)`,
+        sesionId, 'observacion', JSON.stringify(contexto), 1.0
+      );
+      // Log en git_context_log si la tabla existe
+      try {
+        db.run(
+          `INSERT INTO git_context_log (sesion_id, rama, commit_hash, archivos_modificados, riesgos_detectados, predicciones, tiene_riesgos_altos)
+           VALUES (?,?,?,?,?,?,?)`,
+          sesionId,
+          contexto.rama || '',
+          (contexto.commits_recientes?.[0]?.hash || ''),
+          JSON.stringify(contexto.archivos_modificados || []),
+          JSON.stringify(contexto.riesgos || []),
+          JSON.stringify(contexto.predicciones || []),
+          contexto.tiene_riesgos_altos ? 1 : 0
+        );
+      } catch(e) {}
+    } catch(e) {}
+    if (db.type === 'sqljs' && db.save) db.save();
+    db.close();
+    console.log(gitMod.formatearReporte(resultado));
+  } else {
+    db.close();
+    console.log(`  ${resultado.mensaje}`);
+  }
+}
+
+if (_args[0] === 'predict') {
+  const predMod = getPrediccionModuleGrafo();
+  if (!predMod) { console.log('  prediccion module not available (akdd update)'); process.exit(0); }
+  const db = initDB();
+  predMod.mostrarEstadisticasPrediccion(db);
+  db.close();
+}
+
+if (_args[0] === 'ci-install') {
+  const ciMod = getCICDModuleGrafo();
+  if (!ciMod) { console.log('  cicd module not available (akdd update)'); process.exit(0); }
+  ciMod.instalarWorkflow(ROOT);
+}
+
+if (_args[0] === 'ci-status') {
+  const ciMod = getCICDModuleGrafo();
+  if (!ciMod) { console.log('  cicd module not available (akdd update)'); process.exit(0); }
+  const db = initDB();
+  ciMod.mostrarEstadoCI(db);
+  db.close();
+}
+
+if (_args[0] === 'ci-report') {
+  const ciMod = getCICDModuleGrafo();
+  if (!ciMod) { process.exit(0); } // No fallar CI
+  const db = initDB();
+  const esExito = _args.includes('--success');
+  const outputIdx = _args.indexOf('--output');
+  const outputFile = outputIdx >= 0 ? _args[outputIdx + 1] : null;
+  ciMod.reportarCI(ROOT, db, { esExito, outputFile });
+  if (db.type === 'sqljs' && db.save) db.save();
+  db.close();
+}
+
+if (_args[0] === 'embed-status') {
+  const embMod = getEmbeddingsModuleGrafo();
+  console.log('\n  Embeddings locales — Agentic KDD v2.2\n');
+  if (!embMod) {
+    console.log('  Estado: módulo embeddings.cjs no encontrado');
+    console.log('  Solución: akdd update\n');
+  } else if (!embMod.isAvailable()) {
+    console.log('  Estado: @xenova/transformers no instalado');
+    console.log('  Modelo: all-MiniLM-L6-v2 (23MB, 100% offline)');
+    console.log('  Instalar: akdd embed-install\n');
+  } else {
+    console.log('  Estado: ✓ disponible');
+    console.log(`  Modelo: ${embMod.MODELO}`);
+    console.log(`  Dimensiones: ${embMod.DIM}`);
+    console.log('  Búsqueda: vectorial híbrida (RRF)\n');
+  }
+}
+
+if (_args[0] === 'embed-install') {
+  const embMod = getEmbeddingsModuleGrafo();
+  if (!embMod) { console.log('\n  akdd update primero\n'); process.exit(1); }
+  embMod.instalar();
+}
+
+// ─── v2.2: Lazy loaders de módulos (sin romper arranque si no existen) ────────
+function getEmbeddingsModuleGrafo() {
+  try {
+    const p = path.join(__dirname, 'embeddings.cjs');
+    return fs.existsSync(p) ? require(p) : null;
+  } catch(e) { return null; }
+}
+function getGitContextModuleGrafo() {
+  try {
+    const p = path.join(__dirname, 'git-context.cjs');
+    return fs.existsSync(p) ? require(p) : null;
+  } catch(e) { return null; }
+}
+function getPrediccionModuleGrafo() {
+  try {
+    const p = path.join(__dirname, 'prediccion.cjs');
+    return fs.existsSync(p) ? require(p) : null;
+  } catch(e) { return null; }
+}
+function getCICDModuleGrafo() {
+  try {
+    const p = path.join(__dirname, 'cicd.cjs');
+    return fs.existsSync(p) ? require(p) : null;
+  } catch(e) { return null; }
+}
+
+// ─── v2.2: buscar con embeddings (async) ────────────────────────────────────
+async function buscarHibridoConEmbeddings(query, area, topK) {
+  const embMod = getEmbeddingsModuleGrafo();
+  const db = initDB();
+  
+  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 ? db.all(sqlNodos, area) : db.all(sqlNodos);
+  
+  let sqlEp = `SELECT *, 'episodica' as memoria_tipo FROM episodios WHERE relevancia > 0.3`;
+  if (area && area !== 'global') sqlEp += ` AND (area=? OR area='global')`;
+  sqlEp += ' ORDER BY fecha DESC LIMIT 50';
+  const episodiosAll = area ? db.all(sqlEp, area) : db.all(sqlEp);
+  
+  const entidadesAll = db.all("SELECT *, 'semantica' as memoria_tipo FROM entidades LIMIT 100");
+  db.close();
+  
+  const todos = [...nodosAll, ...episodiosAll, ...entidadesAll];
+  if (embMod && embMod.isAvailable()) {
+    return await embMod.buscarHibridoVectorial(todos, query, topK || 10);
+  }
+  return buscarHibrido(query, area, topK).resultados;
+}
+
+// ─── v2.2: sync extendido (git-context + embeddings) ─────────────────────────
+// Se activa con: node grafo.cjs sync-v2
+if (_args[0] === 'sync-v2') {
+  (async () => {
+    // 1. Sync normal
+    sincronizar();
+    
+    const db = initDB();
+    
+    // 2. Git context
+    const gitMod = getGitContextModuleGrafo();
+    if (gitMod && gitMod.gitDisponible(ROOT)) {
+      const resultado = gitMod.analizarGitContext(ROOT, db);
+      if (resultado.disponible && resultado.contexto) {
+        const { riesgos, predicciones } = resultado.contexto;
+        if (riesgos?.some(r => r.nivel === 'ALTO')) {
+          console.log('\n  ⚠️  ALERTAS:');
+          riesgos.filter(r => r.nivel === 'ALTO').slice(0, 3).forEach(r => 
+            console.log(`  🔴 [ALTO] ${r.archivo}: ${r.advertencia || ''}`));
+        }
+        if (predicciones?.length > 0) {
+          console.log('  ⚡ Predicciones:');
+          predicciones.slice(0, 3).forEach(p => console.log(`  · ${p.mensaje}`));
+        }
+        // Guardar en working_memory
+        const sesionId = `sync-v2-${Date.now()}`;
+        try {
+          db.run('UPDATE working_memory SET expirado=1 WHERE expirado=0');
+          db.run(
+            `INSERT INTO working_memory (sesion_id, tipo, contenido, relevancia) VALUES (?,?,?,?)`,
+            sesionId, 'observacion', JSON.stringify(resultado.contexto), 1.0
+          );
+        } catch(e) {}
+      }
+    }
+    
+    // 3. Embeddings — indexar pendientes
+    const embMod = getEmbeddingsModuleGrafo();
+    if (embMod && embMod.isAvailable()) {
+      process.stdout.write('  Embeddings: indexando... ');
+      try {
+        const r = await embMod.indexarPendientes(db, 30);
+        console.log(r.indexados > 0 ? `✓ (${r.indexados} nuevos)` : '✓ (al día)');
+      } catch(e) { console.log(''); }
+    }
+    
+    if (db.type === 'sqljs' && db.save) db.save();
+    db.close();
+  })();
+}
+
+// ─── v2.2: predicción para Context Guard ─────────────────────────────────────
+if (_args[0] === 'predecir') {
+  const predMod = getPrediccionModuleGrafo();
+  if (!predMod) { console.log(JSON.stringify({ nivel_riesgo: 'BAJO', alertas: [] })); process.exit(0); }
+  try {
+    const tarea   = _args[1] || '';
+    const archivos = _args[2] ? JSON.parse(_args[2]) : [];
+    const modulo  = _args[3] || 'global';
+    const db = initDB();
+    const resultado = predMod.evaluarRiesgoTarea(tarea, archivos, modulo, db);
+    db.close();
+    console.log(JSON.stringify(resultado, null, 2));
+  } catch(e) { console.log(JSON.stringify({ nivel_riesgo: 'BAJO', alertas: [], error: e.message })); }
+}
+
+// ─── v2.2: schema migration ───────────────────────────────────────────────────
+// Las nuevas tablas se crean automáticamente en el próximo initDB()
+// grafo.cjs ya llama migrateDB() que tiene las ALTER TABLE
+// Solo hay que asegurar que las nuevas tablas de git_context_log, etc. se crean
+
+// ─── v3.1: Migración para AST, Knowledge Base y Bi-temporal ─────────────────
+// Agentic KDD v3.1 — Nuevas tablas y columnas para Fases 1-3
+// Esta función se llama automáticamente en la siguiente ejecución.
+
+function migrateV3_1(db) {
+  // Columnas bi-temporales en relaciones_semanticas
+  const biTemporalMigrations = [
+    "ALTER TABLE relaciones_semanticas ADD COLUMN valid_at TEXT DEFAULT (datetime('now'))",
+    "ALTER TABLE relaciones_semanticas ADD COLUMN invalid_at TEXT",
+    "ALTER TABLE relaciones_semanticas ADD COLUMN expired_at TEXT",
+    "ALTER TABLE relaciones_semanticas ADD COLUMN episode_id TEXT",
+    "ALTER TABLE relaciones_semanticas ADD COLUMN confidence TEXT DEFAULT 'MEDIA'",
+    "ALTER TABLE relaciones_semanticas ADD COLUMN context TEXT",
+    "ALTER TABLE relaciones_semanticas ADD COLUMN source TEXT DEFAULT 'agent'",
+  ];
+  biTemporalMigrations.forEach(sql => { try { db.exec(sql); } catch(e) {} });
+
+  // Índices bi-temporales
+  const biTemporalIndices = [
+    "CREATE INDEX IF NOT EXISTS idx_rel_sem_valid ON relaciones_semanticas(valid_at)",
+    "CREATE INDEX IF NOT EXISTS idx_rel_sem_invalid ON relaciones_semanticas(invalid_at)",
+    "CREATE INDEX IF NOT EXISTS idx_rel_sem_type ON relaciones_semanticas(tipo)",
+  ];
+  biTemporalIndices.forEach(sql => { try { db.exec(sql); } catch(e) {} });
+
+  // Tabla AST Symbols
+  const astSymbolsSQL = `
+    CREATE TABLE IF NOT EXISTS ast_symbols (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      file         TEXT NOT NULL,
+      language     TEXT NOT NULL,
+      symbol_name  TEXT NOT NULL,
+      kind         TEXT NOT NULL,
+      line_start   INTEGER DEFAULT 0,
+      line_end     INTEGER DEFAULT 0,
+      exported     INTEGER DEFAULT 0,
+      signature    TEXT,
+      pagerank     REAL DEFAULT 0.0,
+      last_indexed TEXT DEFAULT (datetime('now')),
+      content_hash TEXT
+    )`;
+  try { db.exec(astSymbolsSQL); } catch(e) {}
+  try { db.exec("CREATE UNIQUE INDEX IF NOT EXISTS idx_ast_sym_uniq ON ast_symbols(file, symbol_name, kind)"); } catch(e) {}
+  try { db.exec("CREATE INDEX IF NOT EXISTS idx_ast_sym_file ON ast_symbols(file)"); } catch(e) {}
+
+  // Tabla AST Edges
+  const astEdgesSQL = `
+    CREATE TABLE IF NOT EXISTS ast_edges (
+      id           INTEGER PRIMARY KEY AUTOINCREMENT,
+      from_file    TEXT NOT NULL,
+      to_file      TEXT,
+      from_symbol  TEXT,
+      to_symbol    TEXT,
+      kind         TEXT NOT NULL,
+      weight       REAL DEFAULT 1.0,
+      pagerank_src REAL DEFAULT 0.0,
+      last_indexed TEXT DEFAULT (datetime('now'))
+    )`;
+  try { db.exec(astEdgesSQL); } catch(e) {}
+  try { db.exec("CREATE INDEX IF NOT EXISTS idx_ast_edge_from ON ast_edges(from_file)"); } catch(e) {}
+  try { db.exec("CREATE INDEX IF NOT EXISTS idx_ast_edge_to ON ast_edges(to_file)"); } catch(e) {}
+
+  // Tabla Knowledge Docs (ADRs, gotchas, convenciones)
+  const knowledgeDocsSQL = `
+    CREATE TABLE IF NOT EXISTS knowledge_docs (
+      id              INTEGER PRIMARY KEY AUTOINCREMENT,
+      doc_id          TEXT NOT NULL UNIQUE,
+      tipo            TEXT NOT NULL,
+      titulo          TEXT NOT NULL,
+      status          TEXT DEFAULT 'accepted',
+      fecha           TEXT,
+      decision_makers TEXT DEFAULT '[]',
+      afecta          TEXT DEFAULT '[]',
+      frontmatter     TEXT DEFAULT '{}',
+      contenido       TEXT,
+      context         TEXT,
+      decision        TEXT,
+      consequences    TEXT,
+      options         TEXT DEFAULT '[]',
+      file_path       TEXT,
+      last_indexed    TEXT DEFAULT (datetime('now')),
+      content_hash    TEXT
+    )`;
+  try { db.exec(knowledgeDocsSQL); } catch(e) {}
+  try { db.exec("CREATE INDEX IF NOT EXISTS idx_kdocs_tipo ON knowledge_docs(tipo)"); } catch(e) {}
+  try { db.exec("CREATE INDEX IF NOT EXISTS idx_kdocs_status ON knowledge_docs(status)"); } catch(e) {}
+
+  // campo gate_result en fases (para harness tracking)
+  try { db.exec("ALTER TABLE fases ADD COLUMN gate_result TEXT"); } catch(e) {}
+  try { db.exec("ALTER TABLE fases ADD COLUMN harness_passed INTEGER DEFAULT 0"); } catch(e) {}
+
+  // campo ast_indexed en ciclos
+  try { db.exec("ALTER TABLE ciclos ADD COLUMN ast_indexed INTEGER DEFAULT 0"); } catch(e) {}
+  try { db.exec("ALTER TABLE ciclos ADD COLUMN knowledge_loaded INTEGER DEFAULT 0"); } catch(e) {}
+}
+
+// Auto-run migrateV3_1 when grafo.cjs is first loaded
+(function autoMigrateV3_1() {
+  try {
+    const _dbForMigration = initDB();
+    migrateV3_1(_dbForMigration);
+    if (_dbForMigration.save) _dbForMigration.save();
+    _dbForMigration.close();
+  } catch(e) {
+    // Silent — migration runs opportunistically
+  }
+})();
+
+// Export migrateV3_1
+const _exportsV31 = module.exports || {};
+module.exports = { ..._exportsV31, migrateV3_1 };
+
+
+// ─── v3.2: Vigencia de Memoria + Verdad Vigente ────────────────────────────
+// Cierra el Gap #1: límite claro entre memoria vigente, histórica y evidencia
+
+function migrateV3_2(db) {
+  // Columna vigencia_tipo en nodos
+  try { db.exec("ALTER TABLE nodos ADD COLUMN vigencia_tipo TEXT DEFAULT 'VIGENTE'"); } catch {}
+  try { db.exec("CREATE INDEX IF NOT EXISTS idx_nodos_vigencia ON nodos(vigencia_tipo)"); } catch {}
+  // Inferir vigencia_tipo para registros existentes
+  try {
+    db.exec("UPDATE nodos SET vigencia_tipo='OBSOLETO' WHERE estado='OBSOLETO' AND vigencia_tipo='VIGENTE'");
+    db.exec("UPDATE nodos SET vigencia_tipo='HISTORICO' WHERE estado='CONSOLIDADO' AND vigencia_tipo='VIGENTE'");
+  } catch {}
+}
+
+// Auto-run
+(function autoMigrateV3_2() {
+  try {
+    const _db = initDB();
+    migrateV3_2(_db);
+    if (_db.save) _db.save();
+    _db.close();
+  } catch {}
+})();
+
+const _exportsV32 = module.exports || {};
+module.exports = { ..._exportsV32, migrateV3_2 };
+
+
+// ─── v3.2: AUTO-INTEGRATION — MemCurator + llms-generator ─────────────────────
+// Se hookan automáticamente en el flujo de sync existente.
+
+const _grafoPath = __dirname;
+
+function _autoRunCurator() {
+  try {
+    const db = initDB();
+    // Contar ciclos desde última curation
+    let lastCuration = 0;
+    try {
+      const meta = db.prepare("SELECT valor FROM metadata WHERE clave='last_curator_cycle'").get();
+      lastCuration = parseInt(meta?.valor || '0');
+    } catch {}
+    const totalCycles = db.prepare("SELECT COUNT(*) as n FROM ciclos").get()?.n || 0;
+    if (totalCycles - lastCuration >= 10) {
+      const { runCuration } = require(require('path').join(_grafoPath, 'mem-curator.cjs'));
+      runCuration(process.cwd());
+      try {
+        db.prepare("INSERT OR REPLACE INTO metadata (clave, valor) VALUES ('last_curator_cycle', ?)").run(String(totalCycles));
+      } catch {
+        try { db.prepare("CREATE TABLE IF NOT EXISTS metadata (clave TEXT PRIMARY KEY, valor TEXT)").run(); } catch {}
+        try { db.prepare("INSERT OR REPLACE INTO metadata (clave, valor) VALUES ('last_curator_cycle', ?)").run(String(totalCycles)); } catch {}
+      }
+    }
+    if (db.save) db.save(); db.close();
+  } catch {}
+}
+
+function _autoGenerateLlms() {
+  try {
+    const { generateAll } = require(require('path').join(_grafoPath, 'llms-generator.cjs'));
+    generateAll(process.cwd());
+  } catch {}
+}
+
+// Hookar en la función sincronizar existente
+const _origExports = module.exports || {};
+const _origSync = _origExports.sincronizar;
+if (_origSync && typeof _origSync === 'function') {
+  _origExports.sincronizar = function(...args) {
+    const result = _origSync.apply(this, args);
+    try { _autoRunCurator(); } catch {}
+    try { _autoGenerateLlms(); } catch {}
+    return result;
+  };
+}
+
+module.exports = { ..._origExports };
+
+// ─── v3.3: CONTRACT GUARD + CREATIVE ENGINE AUTO-INTEGRATION ─────────────────
+
+function _autoRunContractGuard(cicloId, testOutput) {
+  try {
+    const db = initDB();
+    const cg = require(require('path').join(__dirname, 'contract-guard.cjs'));
+    cg.migrateSchema(db);
+    if (testOutput) {
+      cg.ingestFromCycle(db, process.cwd(), cicloId, testOutput);
+    }
+    if (db.save) db.save(); db.close();
+  } catch {}
+}
+
+function _autoRunCreativeEngine(cicloId) {
+  try {
+    const db = initDB();
+    const ce = require(require('path').join(__dirname, 'creative-engine.cjs'));
+    ce.migrateSchema(db);
+    const result = ce.runCreativePass(db, process.cwd(), cicloId);
+    if (result.new_suggestions > 0 || result.auto_applied > 0) {
+      console.error(`[CREATIVE] Level ${result.level}: ${result.new_suggestions} suggestions, ${result.auto_applied} auto-applied`);
+    }
+    if (db.save) db.save(); db.close();
+  } catch {}
+}
+
+// Hook into existing exports
+const _contractCreativeExports = module.exports || {};
+const _origSyncCC = _contractCreativeExports.sincronizar;
+if (_origSyncCC && typeof _origSyncCC === 'function') {
+  _contractCreativeExports.sincronizar = function(...args) {
+    const result = _origSyncCC.apply(this, args);
+    const cicloId = `sync-${Date.now()}`;
+    try { _autoRunContractGuard(cicloId, null); } catch {}
+    try { _autoRunCreativeEngine(cicloId); } catch {}
+    return result;
+  };
+}
+
+module.exports = { ..._contractCreativeExports };
+
+// ─── v3.3: SESSION GUARD AUTO-CHECKPOINT ──────────────────────────────────────
+function _autoSessionGuard() {
+  try {
+    const db = initDB();
+    const cycles = db.prepare("SELECT COUNT(*) as n FROM ciclos").get()?.n || 0;
+    if (cycles > 0 && cycles % 5 === 0) {
+      const { generateCheckpoint } = require(require('path').join(__dirname, 'session-guard.cjs'));
+      generateCheckpoint(process.cwd());
+      console.error('[SESSION] Checkpoint guardado (.agentic/checkpoint.md)');
+    }
+    if (db.save) db.save(); db.close();
+  } catch {}
+}
+
+const _sgExports = module.exports || {};
+const _origSyncSG = _sgExports.sincronizar;
+if (_origSyncSG && typeof _origSyncSG === 'function') {
+  _sgExports.sincronizar = function(...args) {
+    const result = _origSyncSG.apply(this, args);
+    try { _autoSessionGuard(); } catch {}
+    return result;
+  };
+}
+module.exports = { ..._sgExports };
+
+// ─── v3.3: AUTONOMOUS DECISION ENGINE AUTO-INTEGRATION ────────────────────────
+// Se hookea en el sync para correr la cola diferida al final de cada ciclo
+
+function _autoFlushDeferred() {
+  try {
+    const { flushDeferredQueue } = require(require('path').join(__dirname, 'autonomous-decision.cjs'));
+    const flushed = flushDeferredQueue(process.cwd());
+    if (flushed.length > 0) {
+      console.error(`[AUTONOMOUS] ${flushed.length} deferred item(s) from queue — review as suggestions`);
+      // Add to creative engine suggestions
+      try {
+        const { addSuggestion } = require(require('path').join(__dirname, 'creative-engine.cjs'));
+        const db = initDB();
+        flushed.forEach(item => {
+          addSuggestion(db, {
+            type: 'OPPORTUNITY',
+            title: item.task || 'Deferred task',
+            description: item.reason || 'Deferred by Autonomous Decision Engine',
+            module: (item.files || [])[0] || 'global',
+          }, `deferred-${Date.now()}`);
+        });
+        if (db.save) db.save(); db.close();
+      } catch {}
+    }
+  } catch {}
+}
+
+const _adExports = module.exports || {};
+const _origSyncAD = _adExports.sincronizar;
+if (_origSyncAD && typeof _origSyncAD === 'function') {
+  _adExports.sincronizar = function(...args) {
+    const result = _origSyncAD.apply(this, args);
+    try { _autoFlushDeferred(); } catch {}
+    return result;
+  };
+}
+module.exports = { ..._adExports };
+
+// ─── v3.4: kdd-memory + knowledge-validator + telemetry INTEGRATION ─────────
+
+function _autoKDDMemorySync() {
+  try {
+    const { syncFTS } = require(require('path').join(__dirname, 'kdd-memory.cjs'));
+    const db = initDB();
+    const nodeCount = db.prepare("SELECT COUNT(*) as n FROM nodos WHERE estado='ACTIVO'").get()?.n || 0;
+    let ftsCount = 0;
+    try { ftsCount = db.prepare("SELECT COUNT(*) as n FROM nodos_fts").get()?.n || 0; } catch {}
+    if (ftsCount < nodeCount * 0.9) {
+      syncFTS(db);
+      console.error('[KDD-MEMORY] FTS index synced');
+    }
+    if (db.save) db.save(); db.close();
+  } catch {}
+}
+
+function _autoKnowledgeValidation() {
+  try {
+    const { scanAll } = require(require('path').join(__dirname, 'knowledge-validator.cjs'));
+    const result = scanAll(process.cwd());
+    if (result.sospechoso > 0 || result.poison_candidates > 0) {
+      console.error(`[VALIDATOR] ${result.sospechoso} suspicious + ${result.poison_candidates} poison candidates`);
+    }
+  } catch {}
+}
+
+const _kdmExports = module.exports || {};
+const _origSyncKDM = _kdmExports.sincronizar;
+if (_origSyncKDM && typeof _origSyncKDM === 'function') {
+  _kdmExports.sincronizar = function(...args) {
+    const result = _origSyncKDM.apply(this, args);
+    try { _autoKDDMemorySync(); } catch {}
+    return result;
+  };
+}
+module.exports = { ..._kdmExports };
+
+// ─── v3.6: project_settings — config persistente en BD ──────────────────────
+// Guarda CONFIGURADO, nombre, stack y test command en memoria.db
+// Fuente de verdad secundaria cuando config.md falla o se pisa durante update
+
+(function migrateProjectSettings() {
+  try {
+    const _db = initDB();
+
+    // Crear tabla project_settings si no existe
+    _db.exec(`
+      CREATE TABLE IF NOT EXISTS project_settings (
+        key        TEXT PRIMARY KEY,
+        value      TEXT NOT NULL,
+        updated_at TEXT DEFAULT (datetime('now'))
+      )
+    `);
+
+    // Leer config.md y sincronizar a BD si CONFIGURADO: SI
+    const fs   = require('fs');
+    const path = require('path');
+    const configPath = path.join(process.cwd(), '.agentic', 'config.md');
+
+    if (fs.existsSync(configPath)) {
+      const config = fs.readFileSync(configPath, 'utf8');
+      const configured = /^CONFIGURADO:\s*SI/m.test(config);
+
+      if (configured) {
+        // Guardar estado en BD
+        const upsert = _db.prepare(`
+          INSERT INTO project_settings (key, value, updated_at)
+          VALUES (?, ?, datetime('now'))
+          ON CONFLICT(key) DO UPDATE SET value=excluded.value, updated_at=excluded.updated_at
+        `);
+
+        upsert.run('configured', 'true');
+
+        const nameMatch = config.match(/^Nombre:\s*(.+)$/m);
+        if (nameMatch) upsert.run('project_name', nameMatch[1].trim());
+
+        const testMatch = config.match(/^\s*test:\s*(.+)$/m);
+        if (testMatch && testMatch[1].trim() !== '—') {
+          upsert.run('test_command', testMatch[1].trim());
+        }
+
+        const stackBlock = config.match(/^## Stack\n([\s\S]+?)(?=\n##|$)/m);
+        if (stackBlock) upsert.run('stack', stackBlock[1].trim());
+      }
+    } else {
+      // config.md no existe — intentar restaurar desde BD
+      const settings = {};
+      try {
+        const rows = _db.prepare('SELECT key, value FROM project_settings').all();
+        for (const row of rows) settings[row.key] = row.value;
+      } catch {}
+
+      if (settings.configured === 'true' && fs.existsSync(path.join(process.cwd(), '.agentic'))) {
+        // Reconstruir config.md mínimo desde BD
+        const lines = [
+          '# Agentic KDD — Configuración del proyecto',
+          'CONFIGURADO: SI',
+          'VERSION: 2.0',
+          '',
+          '## Proyecto',
+          `Nombre: ${settings.project_name || '(restaurado desde BD)'}`,
+          'Descripción: —',
+          'Tipo: EXISTENTE',
+          '',
+          settings.stack ? `## Stack\n${settings.stack}` : '## Stack\n—',
+          '',
+          '## Comando de tests',
+          settings.test_command ? `test: ${settings.test_command}` : 'test: —',
+        ];
+        fs.writeFileSync(configPath, lines.join('\n'), 'utf8');
+        console.error('[AGENTIC] config.md restaurado desde memoria.db');
+      }
+    }
+
+    if (_db.save) _db.save();
+    _db.close();
+  } catch(e) {
+    // Silent — best effort
+  }
+})();
+
+const _ps36Exports = module.exports || {};
+module.exports = { ..._ps36Exports };