@codexa/cli 9.0.31 → 9.0.33

package/commands/product.ts

@@ -1,4 +1,4 @@
-import { getDb } from "../db/connection";
+import { dbGet, dbAll, dbRun } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { existsSync, readFileSync, writeFileSync } from "fs";
 import { join } from "path";
@@ -31,12 +31,11 @@ interface ProductFeature {
 // PRODUCT IMPORT - Importa PRD existente
 // ═══════════════════════════════════════════════════════════════
 
-export function productImport(options: { file?: string; content?: string }): void {
-  initSchema();
-  const db = getDb();
+export async function productImport(options: { file?: string; content?: string }): Promise<void> {
+  await initSchema();
 
   // Verificar se ja existe
-  const existing = db.query("SELECT * FROM product_context WHERE id = 'default'").get();
+  const existing = await dbGet("SELECT * FROM product_context WHERE id = 'default'", ["default"]);
   if (existing) {
     console.log("\nContexto de produto ja definido.");
     console.log("Use: product reset para refazer\n");
@@ -58,7 +57,7 @@ export function productImport(options: { file?: string; content?: string }): voi
 
   // Salvar como pendente para o agente processar
   const now = new Date().toISOString();
-  db.run(
+  await dbRun(
     `INSERT INTO product_context (id, name, problem, source, discovered_at, updated_at)
      VALUES ('pending', 'Pendente - PRD Importado', ?, 'import', ?, ?)`,
     [prdContent, now, now]
@@ -86,7 +85,7 @@ Comando para ver o PRD:
 // PRODUCT SET - Define campos do produto
 // ═══════════════════════════════════════════════════════════════
 
-export function productSet(options: {
+export async function productSet(options: {
   name?: string;
   problem?: string;
   solution?: string;
@@ -97,17 +96,16 @@ export function productSet(options: {
   constraints?: string;
   goal?: string;
   feature?: string;
-}): void {
-  initSchema();
-  const db = getDb();
+}): Promise<void> {
+  await initSchema();
 
   // Buscar pendente ou criar novo
-  let pending = db.query("SELECT * FROM product_context WHERE id = 'pending'").get() as any;
+  let pending = await dbGet<any>("SELECT * FROM product_context WHERE id = 'pending'", ["pending"]);
   const now = new Date().toISOString();
 
   if (!pending) {
     // Criar novo registro pendente
-    db.run(
+    await dbRun(
       `INSERT INTO product_context (id, name, problem, source, discovered_at, updated_at)
        VALUES ('pending', 'Pendente', '', 'guide', ?, ?)`,
       [now, now]
@@ -157,7 +155,7 @@ export function productSet(options: {
     values.push(now);
     values.push("pending");
 
-    db.run(
+    await dbRun(
       `UPDATE product_context SET ${updates.join(", ")} WHERE id = ?`,
       values
     );
@@ -170,14 +168,15 @@ export function productSet(options: {
     const goal = parts[1] || options.goal;
     const priority = parts[2] || "medium";
 
-    db.run(
+    await dbRun(
       `INSERT INTO product_goals (product_id, category, goal, priority, created_at)
        VALUES ('pending', ?, ?, ?, ?)`,
       [category, goal, priority, now]
     );
 
-    const count = db.query("SELECT COUNT(*) as c FROM product_goals WHERE product_id = 'pending'").get() as any;
-    console.log(`\nObjetivo adicionado (${count.c} total)`);
+    const countRow = await dbGet<any>("SELECT COUNT(*) as c FROM product_goals WHERE product_id = 'pending'", ["pending"]);
+    const count = countRow?.c ?? 0;
+    console.log(`\nObjetivo adicionado (${count} total)`);
     console.log(`  [${category}] ${goal} (${priority})`);
   }
 
@@ -188,27 +187,28 @@ export function productSet(options: {
     const description = parts[1] || "";
     const priority = parts[2] || "medium";
 
-    db.run(
+    await dbRun(
       `INSERT INTO product_features (product_id, name, description, priority, created_at)
        VALUES ('pending', ?, ?, ?, ?)`,
       [name, description, priority, now]
     );
 
-    const count = db.query("SELECT COUNT(*) as c FROM product_features WHERE product_id = 'pending'").get() as any;
-    console.log(`\nFeature adicionada (${count.c} total)`);
+    const countRow = await dbGet<any>("SELECT COUNT(*) as c FROM product_features WHERE product_id = 'pending'", ["pending"]);
+    const count = countRow?.c ?? 0;
+    console.log(`\nFeature adicionada (${count} total)`);
     console.log(`  ${name} (${priority})`);
   }
 
   // Mostrar estado atual
-  const current = db.query("SELECT * FROM product_context WHERE id = 'pending'").get() as any;
+  const current = await dbGet<any>("SELECT * FROM product_context WHERE id = 'pending'", ["pending"]);
 
   console.log("\nContexto de produto atualizado:");
   console.log("─".repeat(40));
-  if (current.name !== "Pendente") console.log(`  Nome: ${current.name}`);
-  if (current.problem) console.log(`  Problema: ${current.problem.substring(0, 50)}...`);
-  if (current.solution) console.log(`  Solucao: ${current.solution.substring(0, 50)}...`);
-  if (current.target_users) console.log(`  Usuarios: ${current.target_users.substring(0, 50)}...`);
-  if (current.value_proposition) console.log(`  Proposta: ${current.value_proposition.substring(0, 50)}...`);
+  if (current && current.name !== "Pendente") console.log(`  Nome: ${current.name}`);
+  if (current?.problem) console.log(`  Problema: ${current.problem.substring(0, 50)}...`);
+  if (current?.solution) console.log(`  Solucao: ${current.solution.substring(0, 50)}...`);
+  if (current?.target_users) console.log(`  Usuarios: ${current.target_users.substring(0, 50)}...`);
+  if (current?.value_proposition) console.log(`  Proposta: ${current.value_proposition.substring(0, 50)}...`);
   console.log("\nPara confirmar: product confirm\n");
 }
 
@@ -216,11 +216,10 @@ export function productSet(options: {
 // PRODUCT CONFIRM - Confirma e salva
 // ═══════════════════════════════════════════════════════════════
 
-export function productConfirm(): void {
-  initSchema();
-  const db = getDb();
+export async function productConfirm(): Promise<void> {
+  await initSchema();
 
-  const pending = db.query("SELECT * FROM product_context WHERE id = 'pending'").get() as any;
+  const pending = await dbGet<any>("SELECT * FROM product_context WHERE id = 'pending'", ["pending"]);
   if (!pending) {
     throw new CodexaError("Nenhum contexto de produto pendente.\nExecute: product import primeiro");
   }
@@ -236,37 +235,39 @@ export function productConfirm(): void {
   const now = new Date().toISOString();
 
   // Desabilitar foreign keys temporariamente para permitir a migração
-  db.run("PRAGMA foreign_keys = OFF");
+  await dbRun("PRAGMA foreign_keys = OFF");
 
   // Deletar goals e features do 'default' ANTES de deletar product_context
-  db.run("DELETE FROM product_goals WHERE product_id = 'default'");
-  db.run("DELETE FROM product_features WHERE product_id = 'default'");
-  db.run("DELETE FROM product_context WHERE id = 'default'");
+  await dbRun("DELETE FROM product_goals WHERE product_id = 'default'", ["default"]);
+  await dbRun("DELETE FROM product_features WHERE product_id = 'default'", ["default"]);
+  await dbRun("DELETE FROM product_context WHERE id = 'default'", ["default"]);
 
   // Mover pending para default (primeiro os filhos, depois o pai)
-  db.run(`UPDATE product_goals SET product_id = 'default' WHERE product_id = 'pending'`);
-  db.run(`UPDATE product_features SET product_id = 'default' WHERE product_id = 'pending'`);
-  db.run(
+  await dbRun(`UPDATE product_goals SET product_id = 'default' WHERE product_id = 'pending'`, ["pending"]);
+  await dbRun(`UPDATE product_features SET product_id = 'default' WHERE product_id = 'pending'`, ["pending"]);
+  await dbRun(
     `UPDATE product_context SET id = 'default', updated_at = ? WHERE id = 'pending'`,
     [now]
   );
 
   // Reabilitar foreign keys
-  db.run("PRAGMA foreign_keys = ON");
+  await dbRun("PRAGMA foreign_keys = ON");
 
   // Gerar arquivo product-context.md
-  generateProductMarkdown();
+  await generateProductMarkdown();
 
-  const goalsCount = db.query("SELECT COUNT(*) as c FROM product_goals WHERE product_id = 'default'").get() as any;
-  const featuresCount = db.query("SELECT COUNT(*) as c FROM product_features WHERE product_id = 'default'").get() as any;
+  const goalsCountRow = await dbGet<any>("SELECT COUNT(*) as c FROM product_goals WHERE product_id = 'default'", ["default"]);
+  const featuresCountRow = await dbGet<any>("SELECT COUNT(*) as c FROM product_features WHERE product_id = 'default'", ["default"]);
+  const goalsCount = goalsCountRow?.c ?? 0;
+  const featuresCount = featuresCountRow?.c ?? 0;
 
   console.log("\n" + "═".repeat(60));
   console.log("PRODUTO CONFIGURADO");
   console.log("═".repeat(60));
   console.log(`
   Nome: ${pending.name}
-  Objetivos: ${goalsCount.c}
-  Features: ${featuresCount.c}
+  Objetivos: ${goalsCount}
+  Features: ${featuresCount}
 
 Arquivo gerado: .codexa/product-context.md
 
@@ -279,12 +280,11 @@ Proximo passo: /codexa:feature para iniciar uma feature
 // PRODUCT SHOW - Mostra contexto atual
 // ═══════════════════════════════════════════════════════════════
 
-export function productShow(options: { json?: boolean; pending?: boolean } = {}): void {
-  initSchema();
-  const db = getDb();
+export async function productShow(options: { json?: boolean; pending?: boolean } = {}): Promise<void> {
+  await initSchema();
 
   const id = options.pending ? "pending" : "default";
-  const product = db.query(`SELECT * FROM product_context WHERE id = ?`).get(id) as any;
+  const product = await dbGet<any>(`SELECT * FROM product_context WHERE id = ?`, [id]);
 
   if (!product) {
     if (options.pending) {
@@ -294,8 +294,8 @@ export function productShow(options: { json?: boolean; pending?: boolean } = {})
     }
   }
 
-  const goals = db.query(`SELECT * FROM product_goals WHERE product_id = ? ORDER BY priority, category`).all(id) as any[];
-  const features = db.query(`SELECT * FROM product_features WHERE product_id = ? ORDER BY priority`).all(id) as any[];
+  const goals = await dbAll<any>(`SELECT * FROM product_goals WHERE product_id = ? ORDER BY priority, category`, [id]);
+  const features = await dbAll<any>(`SELECT * FROM product_features WHERE product_id = ? ORDER BY priority`, [id]);
 
   if (options.json) {
     console.log(JSON.stringify({
@@ -409,13 +409,12 @@ export function productShow(options: { json?: boolean; pending?: boolean } = {})
 // PRODUCT RESET - Reseta contexto de produto
 // ═══════════════════════════════════════════════════════════════
 
-export function productReset(): void {
-  initSchema();
-  const db = getDb();
+export async function productReset(): Promise<void> {
+  await initSchema();
 
-  db.run("DELETE FROM product_features");
-  db.run("DELETE FROM product_goals");
-  db.run("DELETE FROM product_context");
+  await dbRun("DELETE FROM product_features");
+  await dbRun("DELETE FROM product_goals");
+  await dbRun("DELETE FROM product_context");
 
   console.log("\nContexto de produto resetado.");
   console.log("Execute: product import para refazer\n");
@@ -425,11 +424,10 @@ export function productReset(): void {
 // GENERATE MARKDOWN
 // ═══════════════════════════════════════════════════════════════
 
-function generateProductMarkdown(): void {
-  const db = getDb();
-  const product = db.query("SELECT * FROM product_context WHERE id = 'default'").get() as any;
-  const goals = db.query("SELECT * FROM product_goals WHERE product_id = 'default' ORDER BY priority, category").all() as any[];
-  const features = db.query("SELECT * FROM product_features WHERE product_id = 'default' ORDER BY priority").all() as any[];
+async function generateProductMarkdown(): Promise<void> {
+  const product = await dbGet<any>("SELECT * FROM product_context WHERE id = 'default'", ["default"]);
+  const goals = await dbAll<any>("SELECT * FROM product_goals WHERE product_id = 'default' ORDER BY priority, category", ["default"]);
+  const features = await dbAll<any>("SELECT * FROM product_features WHERE product_id = 'default' ORDER BY priority", ["default"]);
 
   if (!product) return;
 

package/commands/research.ts

@@ -1,4 +1,4 @@
-import { getDb } from "../db/connection";
+import { dbGet, dbAll, dbRun } from "../db/connection";
 import { initSchema } from "../db/schema";
 import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
 import { join } from "path";
@@ -258,14 +258,12 @@ async function detectLibsUniversal(): Promise<DetectedLib[]> {
         if (!result || result.technologies.length === 0) continue;
 
         for (const tech of result.technologies) {
-            // Skip runtime/build categories — those are languages/tools, not libraries
             if (tech.category === "runtime" || tech.category === "build") continue;
 
             const registry = UNIVERSAL_DOCS_REGISTRY[tech.name];
             const canonical = registry?.canonical || tech.name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
             const docsUrl = registry?.docsUrl || "";
 
-            // Deduplicate by canonical name
             if (seen.has(canonical)) continue;
             seen.add(canonical);
 
@@ -347,8 +345,7 @@ ${docsLine}
 // ============================================================
 
 export async function researchStart(options: { json?: boolean } = {}): Promise<void> {
-    initSchema();
-    const db = getDb();
+    await initSchema();
 
     const libs = await detectLibsUniversal();
 
@@ -370,29 +367,26 @@ export async function researchStart(options: { json?: boolean } = {}): Promise<v
     for (const lib of libs) {
         const filePath = join(libContextDir, `${lib.canonical}.md`);
 
-        // Registrar no banco
-        const existingRecord = db
-            .query("SELECT * FROM lib_contexts WHERE lib_name = ?")
-            .get(lib.canonical) as any;
+        const existingRecord = await dbGet<any>(
+            "SELECT * FROM lib_contexts WHERE lib_name = ?",
+            [lib.canonical]
+        );
 
         if (existingRecord) {
-            // Atualizar versao se mudou
             if (existingRecord.version !== lib.version && lib.version) {
-                db.run(
+                await dbRun(
                     "UPDATE lib_contexts SET version = ?, updated_at = ? WHERE lib_name = ?",
                     [lib.version, new Date().toISOString(), lib.canonical]
                 );
             }
             existing.push(lib.canonical);
         } else {
-            // Criar novo registro
-            db.run(
+            await dbRun(
                 `INSERT INTO lib_contexts (lib_name, version, context_file, source_url, researched_at)
                  VALUES (?, ?, ?, ?, ?)`,
                 [lib.canonical, lib.version || "latest", filePath, lib.docsUrl, new Date().toISOString()]
             );
 
-            // Criar arquivo se nao existe
             if (!existsSync(filePath)) {
                 writeFileSync(filePath, generateLibContextTemplate(lib));
             }
@@ -400,7 +394,6 @@ export async function researchStart(options: { json?: boolean } = {}): Promise<v
             created.push(lib.canonical);
         }
 
-        // Registrar mapeamento de agente (com filtro de ecosystem)
         const agentTypes = Object.entries(UNIVERSAL_AGENT_LIB_CATEGORIES)
             .filter(([_, config]) => {
                 const categoryMatch = config.categories.includes(lib.category);
@@ -410,12 +403,13 @@ export async function researchStart(options: { json?: boolean } = {}): Promise<v
             .map(([agent]) => agent);
 
         for (const agentType of agentTypes) {
-            const existingMapping = db
-                .query("SELECT * FROM agent_lib_mappings WHERE agent_type = ? AND lib_name = ?")
-                .get(agentType, lib.canonical);
+            const existingMapping = await dbGet<any>(
+                "SELECT * FROM agent_lib_mappings WHERE agent_type = ? AND lib_name = ?",
+                [agentType, lib.canonical]
+            );
 
             if (!existingMapping) {
-                db.run(
+                await dbRun(
                     "INSERT INTO agent_lib_mappings (agent_type, lib_name, priority) VALUES (?, ?, ?)",
                     [agentType, lib.canonical, 0]
                 );
@@ -424,7 +418,6 @@ export async function researchStart(options: { json?: boolean } = {}): Promise<v
     }
 
     if (options.json) {
-        // Coletar ecossistemas detectados
         const ecosystems = [...new Set(libs.map(l => l.ecosystem))];
         console.log(JSON.stringify({
             detected: libs.length,
@@ -442,7 +435,6 @@ export async function researchStart(options: { json?: boolean } = {}): Promise<v
         return;
     }
 
-    // Coletar ecossistemas
     const ecosystems = [...new Set(libs.map(l => l.ecosystem))];
 
     console.log(`\n${"=".repeat(60)}`);
@@ -451,7 +443,6 @@ export async function researchStart(options: { json?: boolean } = {}): Promise<v
     console.log(`\nEcossistemas: ${ecosystems.join(", ")}`);
     console.log(`Encontradas ${libs.length} bibliotecas:\n`);
 
-    // Agrupar por ecossistema > categoria
     const byEcosystem: Record<string, Record<string, DetectedLib[]>> = {};
     for (const lib of libs) {
         if (!byEcosystem[lib.ecosystem]) {
@@ -495,9 +486,8 @@ export async function researchStart(options: { json?: boolean } = {}): Promise<v
 // COMMAND: research show
 // ============================================================
 
-export function researchShow(options: { json?: boolean; lib?: string } = {}): void {
-    initSchema();
-    const db = getDb();
+export async function researchShow(options: { json?: boolean; lib?: string } = {}): Promise<void> {
+    await initSchema();
 
     let query = "SELECT * FROM lib_contexts";
     let params: any[] = [];
@@ -509,7 +499,7 @@ export function researchShow(options: { json?: boolean; lib?: string } = {}): vo
 
     query += " ORDER BY lib_name";
 
-    const libs = db.query(query).all(...params) as any[];
+    const libs = await dbAll<any>(query, params);
 
     if (libs.length === 0) {
         if (options.json) {
@@ -522,17 +512,18 @@ export function researchShow(options: { json?: boolean; lib?: string } = {}): vo
     }
 
     if (options.json) {
-        // Adicionar mapeamentos de agentes
-        const result = libs.map(lib => {
-            const mappings = db
-                .query("SELECT agent_type FROM agent_lib_mappings WHERE lib_name = ?")
-                .all(lib.lib_name) as any[];
+        const result = [];
+        for (const lib of libs) {
+            const mappings = await dbAll<any>(
+                "SELECT agent_type FROM agent_lib_mappings WHERE lib_name = ?",
+                [lib.lib_name]
+            );
 
-            return {
+            result.push({
                 ...lib,
                 agents: mappings.map(m => m.agent_type)
-            };
-        });
+            });
+        }
 
         console.log(JSON.stringify({ libs: result }, null, 2));
         return;
@@ -543,9 +534,10 @@ export function researchShow(options: { json?: boolean; lib?: string } = {}): vo
     console.log(`${"=".repeat(60)}\n`);
 
     for (const lib of libs) {
-        const mappings = db
-            .query("SELECT agent_type FROM agent_lib_mappings WHERE lib_name = ?")
-            .all(lib.lib_name) as any[];
+        const mappings = await dbAll<any>(
+            "SELECT agent_type FROM agent_lib_mappings WHERE lib_name = ?",
+            [lib.lib_name]
+        );
 
         const fileExists = existsSync(lib.context_file);
         let status = "pendente";
@@ -576,13 +568,13 @@ export function researchShow(options: { json?: boolean; lib?: string } = {}): vo
 // COMMAND: research fill
 // ============================================================
 
-export function researchFill(libName: string, options: { json?: boolean } = {}): void {
-    initSchema();
-    const db = getDb();
+export async function researchFill(libName: string, options: { json?: boolean } = {}): Promise<void> {
+    await initSchema();
 
-    const lib = db
-        .query("SELECT * FROM lib_contexts WHERE lib_name = ?")
-        .get(libName) as any;
+    const lib = await dbGet<any>(
+        "SELECT * FROM lib_contexts WHERE lib_name = ?",
+        [libName]
+    );
 
     if (!lib) {
         if (options.json) {
@@ -596,7 +588,6 @@ export function researchFill(libName: string, options: { json?: boolean } = {}):
 
     const versionStr = lib.version && lib.version !== "latest" ? lib.version : "latest";
 
-    // Retornar instrucoes para o agente preencher
     const instructions = {
         lib_name: lib.lib_name,
         version: lib.version,
@@ -638,33 +629,34 @@ FORMATO DO ARQUIVO:
 // COMMAND: research map-agent
 // ============================================================
 
-export function researchMapAgent(options: {
+export async function researchMapAgent(options: {
     agent: string;
     add?: string;
     remove?: string;
     json?: boolean;
-}): void {
-    initSchema();
-    const db = getDb();
+}): Promise<void> {
+    await initSchema();
 
     if (options.add) {
         const libs = options.add.split(",").map(s => s.trim());
         for (const lib of libs) {
-            const existingLib = db
-                .query("SELECT * FROM lib_contexts WHERE lib_name = ?")
-                .get(lib);
+            const existingLib = await dbGet<any>(
+                "SELECT * FROM lib_contexts WHERE lib_name = ?",
+                [lib]
+            );
 
             if (!existingLib) {
                 console.error(`\nBiblioteca '${lib}' nao encontrada. Execute research start primeiro.\n`);
                 continue;
             }
 
-            const existing = db
-                .query("SELECT * FROM agent_lib_mappings WHERE agent_type = ? AND lib_name = ?")
-                .get(options.agent, lib);
+            const existingMapping = await dbGet<any>(
+                "SELECT * FROM agent_lib_mappings WHERE agent_type = ? AND lib_name = ?",
+                [options.agent, lib]
+            );
 
-            if (!existing) {
-                db.run(
+            if (!existingMapping) {
+                await dbRun(
                     "INSERT INTO agent_lib_mappings (agent_type, lib_name) VALUES (?, ?)",
                     [options.agent, lib]
                 );
@@ -676,7 +668,7 @@ export function researchMapAgent(options: {
     if (options.remove) {
         const libs = options.remove.split(",").map(s => s.trim());
         for (const lib of libs) {
-            db.run(
+            await dbRun(
                 "DELETE FROM agent_lib_mappings WHERE agent_type = ? AND lib_name = ?",
                 [options.agent, lib]
             );
@@ -684,10 +676,10 @@ export function researchMapAgent(options: {
         }
     }
 
-    // Mostrar mapeamentos atuais
-    const mappings = db
-        .query("SELECT lib_name FROM agent_lib_mappings WHERE agent_type = ? ORDER BY lib_name")
-        .all(options.agent) as any[];
+    const mappings = await dbAll<any>(
+        "SELECT lib_name FROM agent_lib_mappings WHERE agent_type = ? ORDER BY lib_name",
+        [options.agent]
+    );
 
     if (options.json) {
         console.log(JSON.stringify({ agent: options.agent, libs: mappings.map(m => m.lib_name) }));
@@ -708,12 +700,11 @@ export function researchMapAgent(options: {
 // COMMAND: research reset
 // ============================================================
 
-export function researchReset(): void {
-    initSchema();
-    const db = getDb();
+export async function researchReset(): Promise<void> {
+    await initSchema();
 
-    db.run("DELETE FROM agent_lib_mappings");
-    db.run("DELETE FROM lib_contexts");
+    await dbRun("DELETE FROM agent_lib_mappings");
+    await dbRun("DELETE FROM lib_contexts");
 
     console.log("\nResearch resetado. Todos os contextos de biblioteca foram removidos.");
     console.log("Execute: research start para redetectar.\n");
@@ -724,27 +715,23 @@ export function researchReset(): void {
 // Used by utils.ts to inject lib context into subagent prompts.
 // ============================================================
 
-export function getLibContextsForAgent(agentType: string): string[] {
-    initSchema();
-    const db = getDb();
+export async function getLibContextsForAgent(agentType: string): Promise<string[]> {
+    await initSchema();
 
-    // Buscar libs mapeadas para o agente
-    const mappings = db
-        .query(`
-            SELECT lc.context_file
+    const mappings = await dbAll<any>(
+        `SELECT lc.context_file
             FROM agent_lib_mappings alm
             JOIN lib_contexts lc ON alm.lib_name = lc.lib_name
             WHERE alm.agent_type = ? OR alm.agent_type = ?
-            ORDER BY alm.priority DESC
-        `)
-        .all(agentType, agentType.split("-")[0]) as any[];
+            ORDER BY alm.priority DESC`,
+        [agentType, agentType.split("-")[0]]
+    );
 
     const contexts: string[] = [];
 
     for (const mapping of mappings) {
         if (existsSync(mapping.context_file)) {
             const content = readFileSync(mapping.context_file, "utf-8");
-            // So inclui se nao estiver pendente
             if (!content.includes("status: pending-research")) {
                 contexts.push(content);
             }