@arcadialdev/arcality 3.0.0 → 3.0.2

package/tests/_helpers/agentic-runner.bundle.spec.js

@@ -815,8 +815,8 @@ async function scan_sensitive_data_exposure(page) {
 }
 
 // tests/_helpers/ai-agent-helper.ts
-var fs3 = __toESM(require("fs"));
-var path3 = __toESM(require("path"));
+var fs4 = __toESM(require("fs"));
+var path4 = __toESM(require("path"));
 
 // src/KnowledgeService.ts
 var crypto = __toESM(require("crypto"));
@@ -1263,6 +1263,189 @@ async function getKnownFieldIdentifiers(pathUrl) {
   }
 }
 
+// tests/_helpers/qa-context.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+var RECOGNIZED_SECTION_PATTERNS = [
+  /reglas?.*(dominio|negocio)|dominio|negocio|general/i,
+  /navegacion|ui|interfaz|flujo/i,
+  /prohibid|anti-patron|anti patron|nunca/i,
+  /datos|credenciales|usuarios?|cuentas?/i,
+  /resultado|validacion|assert|exito|esperad/i
+];
+var PLACEHOLDER_PATTERNS = [
+  /^ejemplo:/i,
+  /^\(ejemplo/i,
+  /^reemplaza /i,
+  /^describe /i,
+  /^agrega /i,
+  /^completa /i,
+  /^escribe /i,
+  /^si no aplica/i,
+  /^borra /i,
+  /^pendiente$/i,
+  /^\.\.\.$/
+];
+function stripHtmlComments(content) {
+  return content.replace(/<!--[\s\S]*?-->/g, "");
+}
+function normalizeLine(line) {
+  return line.replace(/\t/g, "    ").trim();
+}
+function isBulletLine(line) {
+  return /^[-*+]\s+/.test(line) || /^\d+\.\s+/.test(line);
+}
+function toBulletText(line) {
+  return line.replace(/^[-*+]\s+/, "").replace(/^\d+\.\s+/, "").trim();
+}
+function isPlaceholderRule(rule) {
+  const normalized = normalizeLine(rule);
+  if (!normalized)
+    return true;
+  return PLACEHOLDER_PATTERNS.some((pattern) => pattern.test(normalized));
+}
+function isRecognizedSection(title) {
+  return RECOGNIZED_SECTION_PATTERNS.some((pattern) => pattern.test(title));
+}
+function analyzeQaContext(projectRoot = process.cwd()) {
+  const filePath = path.join(projectRoot, ".arcality", "qa-context.md");
+  const emptyResult = {
+    filePath,
+    exists: false,
+    rawContent: "",
+    sanitizedContent: "",
+    sections: [],
+    ruleCount: 0,
+    sectionCount: 0,
+    recognizedSectionCount: 0,
+    ignoredExampleCount: 0,
+    warnings: [],
+    status: "missing",
+    isValid: false
+  };
+  if (!fs.existsSync(filePath)) {
+    return emptyResult;
+  }
+  const rawContent = fs.readFileSync(filePath, "utf8");
+  const cleanedContent = stripHtmlComments(rawContent);
+  const lines = cleanedContent.split(/\r?\n/);
+  const warnings = [];
+  const sections = [];
+  let currentSection = null;
+  let ignoredExampleCount = 0;
+  const openSection = (title) => {
+    currentSection = {
+      title: title.trim(),
+      recognized: isRecognizedSection(title),
+      rules: []
+    };
+    sections.push(currentSection);
+  };
+  for (const rawLine of lines) {
+    const line = normalizeLine(rawLine);
+    if (!line)
+      continue;
+    if (/^##\s+/.test(line)) {
+      openSection(line.replace(/^##\s+/, "").trim());
+      continue;
+    }
+    if (!isBulletLine(line))
+      continue;
+    if (!currentSection) {
+      openSection("Reglas sin seccion");
+    }
+    const rule = toBulletText(line);
+    if (isPlaceholderRule(rule)) {
+      ignoredExampleCount += 1;
+      continue;
+    }
+    if (currentSection) {
+      currentSection.rules.push(rule);
+    }
+  }
+  const nonEmptySections = sections.filter((section) => section.rules.length > 0);
+  const ruleCount = nonEmptySections.reduce((total, section) => total + section.rules.length, 0);
+  const recognizedSectionCount = nonEmptySections.filter((section) => section.recognized).length;
+  if (!rawContent.trim()) {
+    warnings.push("El archivo existe pero esta vacio.");
+  }
+  if (sections.length === 0 && rawContent.trim()) {
+    warnings.push('No se detectaron secciones markdown con encabezados "##".');
+  }
+  if (ruleCount === 0) {
+    if (ignoredExampleCount > 0) {
+      warnings.push("Solo se detectaron ejemplos o placeholders. Reemplaza los bullets de ejemplo por reglas reales.");
+    } else {
+      warnings.push("No se detectaron reglas accionables. Agrega al menos un bullet real en alguna seccion.");
+    }
+  }
+  if (ruleCount > 0 && recognizedSectionCount === 0) {
+    warnings.push("Hay reglas, pero ninguna cae en las secciones sugeridas. Revisa la estructura del archivo.");
+  }
+  const sanitizedContent = nonEmptySections.map((section) => {
+    const rules = section.rules.map((rule) => `- ${rule}`).join("\n");
+    return `## ${section.title}
+${rules}`;
+  }).join("\n\n");
+  let status = "ready";
+  if (!rawContent.trim())
+    status = "empty";
+  else if (ruleCount === 0 && ignoredExampleCount > 0)
+    status = "template-only";
+  else if (warnings.length > 0)
+    status = "warning";
+  return {
+    filePath,
+    exists: true,
+    rawContent,
+    sanitizedContent,
+    sections: nonEmptySections,
+    ruleCount,
+    sectionCount: nonEmptySections.length,
+    recognizedSectionCount,
+    ignoredExampleCount,
+    warnings,
+    status,
+    isValid: ruleCount > 0
+  };
+}
+function loadQaContextForPrompt(projectRoot = process.cwd()) {
+  const analysis = analyzeQaContext(projectRoot);
+  return {
+    analysis,
+    promptBlock: analysis.isValid ? analysis.sanitizedContent : ""
+  };
+}
+function formatQaContextSummary(analysis) {
+  const lines = [];
+  lines.push("QA Context Summary");
+  lines.push(`Status: ${analysis.status}`);
+  lines.push(`Path: ${analysis.filePath}`);
+  lines.push(`Rules loaded: ${analysis.ruleCount}`);
+  lines.push(`Sections with rules: ${analysis.sectionCount}`);
+  lines.push(`Recognized sections: ${analysis.recognizedSectionCount}`);
+  lines.push(`Ignored examples/placeholders: ${analysis.ignoredExampleCount}`);
+  if (analysis.sections.length > 0) {
+    lines.push("");
+    lines.push("Sections applied:");
+    for (const section of analysis.sections) {
+      lines.push(`- ${section.title}: ${section.rules.length} rule(s)`);
+    }
+  }
+  if (analysis.warnings.length > 0) {
+    lines.push("");
+    lines.push("Warnings:");
+    for (const warning of analysis.warnings) {
+      lines.push(`- ${warning}`);
+    }
+  }
+  if (!analysis.exists) {
+    lines.push("");
+    lines.push("No local QA Context file was found for this mission.");
+  }
+  return lines.join("\n");
+}
+
 // tests/_helpers/ai-agent-helper.ts
 var qaSecurityTools = [
   {
@@ -1311,6 +1494,9 @@ var AIAgentHelper = class {
   sessionStorage = /* @__PURE__ */ new Map();
   criticalNetworkError = null;
   criticalJsError = null;
+  qaContextAnalysisCache = null;
+  qaContextPromptCache = "";
+  qaContextStatusLogged = false;
   constructor(page, contextDir = "out", testInfo, knowledgeService) {
     this.page = page;
     this.contextDir = contextDir;
@@ -1372,29 +1558,29 @@ var AIAgentHelper = class {
     try {
       let skillsContext = "";
       let loadedCount = 0;
-      const toolsRoot = process.env.ARCALITY_ROOT || path3.join(__dirname, "..", "..");
+      const toolsRoot = process.env.ARCALITY_ROOT || path4.join(__dirname, "..", "..");
       const possibleDirs = [
-        path3.join(toolsRoot, ".agent", "skills"),
-        path3.join(toolsRoot, ".agents", "skills")
+        path4.join(toolsRoot, ".agent", "skills"),
+        path4.join(toolsRoot, ".agents", "skills")
       ];
       for (const rootDir of possibleDirs) {
-        if (!fs3.existsSync(rootDir))
+        if (!fs4.existsSync(rootDir))
           continue;
         if (loadedCount === 0) {
           skillsContext += "\n\u{1F6E0}\uFE0F SKILLS INSTALADAS (Metodolog\xEDas activas):\n";
         }
-        const entries = fs3.readdirSync(rootDir, { withFileTypes: true });
+        const entries = fs4.readdirSync(rootDir, { withFileTypes: true });
         for (const entry of entries) {
           let content = "";
           let skillName = entry.name;
           if (entry.isDirectory()) {
-            const skillPath = path3.join(rootDir, entry.name, "SKILL.md");
-            if (fs3.existsSync(skillPath)) {
-              content = fs3.readFileSync(skillPath, "utf8");
+            const skillPath = path4.join(rootDir, entry.name, "SKILL.md");
+            if (fs4.existsSync(skillPath)) {
+              content = fs4.readFileSync(skillPath, "utf8");
             }
           } else if (entry.name.endsWith(".md")) {
-            const skillPath = path3.join(rootDir, entry.name);
-            content = fs3.readFileSync(skillPath, "utf8");
+            const skillPath = path4.join(rootDir, entry.name);
+            content = fs4.readFileSync(skillPath, "utf8");
           }
           if (content) {
             skillsContext += `
@@ -1417,9 +1603,9 @@ ${content}
   }
   loadMemory(prompt) {
     try {
-      const memoryFile = path3.join(this.contextDir, "memoria-agente.json");
-      if (fs3.existsSync(memoryFile)) {
-        const memories = JSON.parse(fs3.readFileSync(memoryFile, "utf8"));
+      const memoryFile = path4.join(this.contextDir, "memoria-agente.json");
+      if (fs4.existsSync(memoryFile)) {
+        const memories = JSON.parse(fs4.readFileSync(memoryFile, "utf8"));
         const keywords = prompt.toLowerCase().split(" ").filter((w) => w.length > 4);
         const relevantSuccess = memories.filter((m) => {
           if (!m.success)
@@ -1790,13 +1976,13 @@ ${relevantFailures.map((m) => `- ${m.prompt}`).join("\n")}
    */
   async getActionFromGuia(prompt, historyLength) {
     try {
-      const fs5 = require("fs");
-      const path5 = require("path");
-      const memoryFile = path5.join(this.contextDir, "memoria-agente.json");
-      if (!fs5.existsSync(memoryFile)) {
+      const fs6 = require("fs");
+      const path6 = require("path");
+      const memoryFile = path6.join(this.contextDir, "memoria-agente.json");
+      if (!fs6.existsSync(memoryFile)) {
         return null;
       }
-      const memories = JSON.parse(fs5.readFileSync(memoryFile, "utf8"));
+      const memories = JSON.parse(fs6.readFileSync(memoryFile, "utf8"));
       const state = await this.getPageState();
       const currentUrl = this.page.url();
       const extractCriticalKeywords = (text) => {
@@ -2082,11 +2268,11 @@ ${relevantFailures.map((m) => `- ${m.prompt}`).join("\n")}
     }
     let customUserContext = "";
     try {
-      const fs5 = require("fs");
-      const path5 = require("path");
-      const customContextPath = path5.join(process.cwd(), ".arcality", "qa-context.md");
-      if (fs5.existsSync(customContextPath)) {
-        const content = fs5.readFileSync(customContextPath, "utf8");
+      const fs6 = require("fs");
+      const path6 = require("path");
+      const customContextPath = path6.join(process.cwd(), ".arcality", "qa-context.md");
+      if (false) {
+        const content = fs6.readFileSync(customContextPath, "utf8");
         customUserContext = `
 <CUSTOMER_BUSINESS_RULES>
 El Ing. de QA o Cliente final ha provisto las siguientes reglas estrictas para este negocio/dominio. DEBES priorizar esta informaci\xF3n sobre todas tus skills base:
@@ -2096,6 +2282,38 @@ ${content}
       }
     } catch (e) {
     }
+    try {
+      if (!this.qaContextAnalysisCache) {
+        const qaContextState = loadQaContextForPrompt(process.cwd());
+        this.qaContextAnalysisCache = qaContextState.analysis;
+        this.qaContextPromptCache = qaContextState.promptBlock;
+      }
+      const qaContextAnalysis = this.qaContextAnalysisCache;
+      if (!this.qaContextStatusLogged) {
+        if (qaContextAnalysis.exists && this.qaContextPromptCache) {
+          console.log(`>>ARCALITY_STATUS>> QA Context local inyectado (${qaContextAnalysis.ruleCount} reglas, ${qaContextAnalysis.sectionCount} secciones).`);
+        } else if (qaContextAnalysis.exists) {
+          console.log(`>>ARCALITY_STATUS>> QA Context local detectado, pero sin reglas utilizables.`);
+        }
+        if (qaContextAnalysis.warnings.length > 0) {
+          for (const warning of qaContextAnalysis.warnings) {
+            console.log(`>>ARCALITY_STATUS>> QA Context warning: ${warning}`);
+          }
+        }
+        this.qaContextStatusLogged = true;
+      }
+      if (this.qaContextPromptCache) {
+        customUserContext = `
+<CUSTOMER_BUSINESS_RULES>
+El Ing. de QA o Cliente final ha provisto reglas locales para este negocio/dominio. Debes priorizar esta informacion sobre tus heuristicas base cuando exista conflicto.
+${this.qaContextPromptCache}
+</CUSTOMER_BUSINESS_RULES>
+`;
+      } else {
+        customUserContext = "";
+      }
+    } catch (e) {
+    }
     const systemPromptBlocks = [
       {
         type: "text",
@@ -3210,8 +3428,8 @@ var SecurityScanner = class {
 
 // tests/_helpers/agentic-runner.spec.ts
 var import_config = require("dotenv/config");
-var fs4 = __toESM(require("fs"));
-var path4 = __toESM(require("path"));
+var fs5 = __toESM(require("fs"));
+var path5 = __toESM(require("path"));
 var crypto2 = __toESM(require("crypto"));
 var _sessionRuleCache = /* @__PURE__ */ new Set();
 function captureValidationRule(errorMessage, context) {
@@ -3242,15 +3460,30 @@ function captureValidationRule(errorMessage, context) {
   const history = [];
   const urlHistory = [];
   const stepsData = [];
-  const memoryFile = path4.join(contextDir, "memoria-arcality.json");
-  if (fs4.existsSync(memoryFile)) {
+  const memoryFile = path5.join(contextDir, "memoria-arcality.json");
+  if (fs5.existsSync(memoryFile)) {
     try {
-      fs4.unlinkSync(memoryFile);
+      fs5.unlinkSync(memoryFile);
     } catch {
     }
   }
   const agent = new AIAgentHelper(page, contextDir, testInfo);
   const prompt = process.env.SMART_PROMPT || "Navega al inicio y verifica que el sitio cargue";
+  const qaContextAnalysis = analyzeQaContext(process.cwd());
+  if (qaContextAnalysis.exists && qaContextAnalysis.isValid) {
+    console.log(`>>ARCALITY_STATUS>> QA Context validado al arranque (${qaContextAnalysis.ruleCount} reglas, ${qaContextAnalysis.sectionCount} secciones).`);
+  } else if (qaContextAnalysis.exists) {
+    console.log(`>>ARCALITY_STATUS>> QA Context detectado con advertencias.`);
+    for (const warning of qaContextAnalysis.warnings) {
+      console.log(`>>ARCALITY_STATUS>> QA Context warning: ${warning}`);
+    }
+  } else {
+    console.log(`>>ARCALITY_STATUS>> QA Context local no configurado para esta mision.`);
+  }
+  await testInfo.attach("qa_context_summary", {
+    body: Buffer.from(formatQaContextSummary(qaContextAnalysis), "utf-8"),
+    contentType: "text/plain"
+  });
   const successKeywords = /exitosamente|creado correctamente|guardado correctamente|misión cumplida|registered successfully|created successfully|saved successfully|operación exitosa|registro guardado|successfully|correctly/i;
   const failureKeywords = /\berror\b|falló|failed|no se puede|cannot|unable|ya existe|already exists|existente|exist|inválido|invalid|incorrecto|incorrect|ligado|linked|depende|depends|duplicado|duplicate|repetido|repeated|conflict|reintentar|retry|missing|required|obligatorio|bad request|400|500/i;
   const systemErrorKeywords = /error interno|internal error|intentarlo más tarde|try again later|inténtelo más tarde|servicio no disponible|service unavailable|something went wrong|algo salió mal|ha ocurrido un error inesperado|unexpected error|server error|no se pudo procesar|could not be processed|comuníquese con soporte|contact support/i;
@@ -3273,14 +3506,14 @@ function captureValidationRule(errorMessage, context) {
     if (resultsSaved)
       return;
     resultsSaved = true;
-    if (!fs4.existsSync(contextDir))
-      fs4.mkdirSync(contextDir, { recursive: true });
+    if (!fs5.existsSync(contextDir))
+      fs5.mkdirSync(contextDir, { recursive: true });
     const finalSuccess = aiMarkedSuccess && !hasCriticalError;
     try {
-      const memoryFile2 = path4.join(contextDir, "memoria-arcality.json");
+      const memoryFile2 = path5.join(contextDir, "memoria-arcality.json");
       let memories = [];
-      if (fs4.existsSync(memoryFile2)) {
-        const content = fs4.readFileSync(memoryFile2, "utf8").trim();
+      if (fs5.existsSync(memoryFile2)) {
+        const content = fs5.readFileSync(memoryFile2, "utf8").trim();
         if (content) {
           try {
             memories = JSON.parse(content);
@@ -3354,16 +3587,16 @@ function captureValidationRule(errorMessage, context) {
         timestamp: Date.now()
       };
       memories.push(missionData);
-      fs4.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
+      fs5.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
       console.log(`>>ARCALITY_STATUS>> \u{1F9E0} Memoria guardada: ${cleanSteps.length} pasos limpios (${rawSteps.length - cleanSteps.length} corruptos filtrados)`);
     } catch (err) {
       console.error("\u274C Fall\xF3 al guardar memoria:", err);
     }
     try {
-      const logPath = path4.join(contextDir, `agent-log-${Date.now()}.json`);
-      fs4.writeFileSync(logPath, JSON.stringify({ prompt, history, steps: stepCount, success: finalSuccess, error: hasCriticalError, fail_reason: failReason, fail_reasoning: failReasoning, usage: totalMissionUsage, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
+      const logPath = path5.join(contextDir, `agent-log-${Date.now()}.json`);
+      fs5.writeFileSync(logPath, JSON.stringify({ prompt, history, steps: stepCount, success: finalSuccess, error: hasCriticalError, fail_reason: failReason, fail_reasoning: failReasoning, usage: totalMissionUsage, timestamp: (/* @__PURE__ */ new Date()).toISOString() }, null, 2));
       try {
-        fs4.appendFileSync(path4.join(contextDir, "arcality-history.log"), JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), mission: prompt.substring(0, 150), success: finalSuccess, steps: stepCount, usage: totalMissionUsage }) + "\n");
+        fs5.appendFileSync(path5.join(contextDir, "arcality-history.log"), JSON.stringify({ ts: (/* @__PURE__ */ new Date()).toISOString(), mission: prompt.substring(0, 150), success: finalSuccess, steps: stepCount, usage: totalMissionUsage }) + "\n");
       } catch (e) {
       }
     } catch (err) {
@@ -3549,11 +3782,11 @@ function captureValidationRule(errorMessage, context) {
           timestamp: Date.now()
         };
         try {
-          const memoryFile2 = path4.join(contextDir, "memoria-agente.json");
+          const memoryFile2 = path5.join(contextDir, "memoria-agente.json");
           let memories = [];
-          if (fs4.existsSync(memoryFile2)) {
+          if (fs5.existsSync(memoryFile2)) {
             try {
-              memories = JSON.parse(fs4.readFileSync(memoryFile2, "utf8"));
+              memories = JSON.parse(fs5.readFileSync(memoryFile2, "utf8"));
             } catch {
               memories = [];
             }
@@ -3565,14 +3798,14 @@ function captureValidationRule(errorMessage, context) {
           if (existingIdx < 0) {
             if (resolvedStepsData.length > 0) {
               memories.push(localMemoryData);
-              fs4.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
+              fs5.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
               console.log(`>>ARCALITY_STATUS>> \u2728 Memoria sincronizada en memoria-agente.json (${resolvedStepsData.length} pasos). Arcality entrar\xE1 en MODO GU\xCDA.`);
             } else {
               console.warn(`>>ARCALITY_STATUS>> \u26A0\uFE0F Memoria NO sincronizada: el patr\xF3n del backend tiene 0 pasos t\xE9cnicos v\xE1lidos (steps_technical vac\xEDo).`);
             }
           } else if (!existingHasSteps && resolvedStepsData.length > 0) {
             memories[existingIdx] = localMemoryData;
-            fs4.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
+            fs5.writeFileSync(memoryFile2, JSON.stringify(memories, null, 2));
             console.log(`>>ARCALITY_STATUS>> \u{1F504} Patr\xF3n corrupto (0 pasos) sobreescrito en memoria-agente.json (${resolvedStepsData.length} pasos nuevos). MODO GU\xCDA activado.`);
           } else {
             console.log(`>>ARCALITY_STATUS>> \u2139\uFE0F Patr\xF3n ya existe en memoria-agente.json con ${(memories[existingIdx]?.steps_data || []).length} pasos. MODO GU\xCDA activado sin re-escritura.`);
@@ -3916,7 +4149,7 @@ Acci\xF3n bloqueada: Bucle de tipo ${loopType} sobre los elementos ${Array.from(
       const lastSixHistory = history.slice(-6);
       const consecutiveWaits = lastSixHistory.filter((h) => h.includes('wait en "')).length;
       if (consecutiveWaits >= 3) {
-        const blankEvidencePath = path4.join(contextDir, `portal-blank-state-${Date.now()}.png`);
+        const blankEvidencePath = path5.join(contextDir, `portal-blank-state-${Date.now()}.png`);
         await page.screenshot({ path: blankEvidencePath, fullPage: true }).catch(() => {
         });
         const blankUrl = page.url();
@@ -4188,7 +4421,7 @@ Acci\xF3n bloqueada: Bucle de tipo ${loopType} sobre los elementos ${Array.from(
                   const panelCount = Math.min(panels.length, 6);
                   if (panelCount >= 2 && emptyPanelCount >= panelCount * 0.6) {
                     const blankUrl = page.url();
-                    const blankEvidencePath = path4.join(contextDir, `portal-blank-dashboard-${Date.now()}.png`);
+                    const blankEvidencePath = path5.join(contextDir, `portal-blank-dashboard-${Date.now()}.png`);
                     await page.screenshot({ path: blankEvidencePath, fullPage: true }).catch(() => {
                     });
                     console.error(`
@@ -4469,8 +4702,8 @@ Acci\xF3n bloqueada: Bucle de tipo ${loopType} sobre los elementos ${Array.from(
       console.log("\u{1F916} [SMART-YAML] Generating mission card...");
     const smartYaml = await agent.summarizeMissionToYaml(prompt, history, target);
     if (smartYaml) {
-      const yamlPath = path4.join(contextDir, "last-mission-smart.yaml");
-      fs4.writeFileSync(yamlPath, smartYaml);
+      const yamlPath = path5.join(contextDir, "last-mission-smart.yaml");
+      fs5.writeFileSync(yamlPath, smartYaml);
       console.log(`>>ARCALITY_STATUS>> \u{1F4DD} Smart Mission Card generated.`);
       await testInfo.attach("smart_mission_card", {
         body: Buffer.from(smartYaml, "utf-8"),
@@ -4542,15 +4775,15 @@ ${failReasoning}
   } else {
     console.log(`>>ARCALITY_STATUS>> \u{1F4CA} Uso total de tokens esta misi\xF3n: IN=${totalMissionUsage.input_tokens} | OUT=${totalMissionUsage.output_tokens} | Cache writes=${totalMissionUsage.cache_creation_input_tokens} | Cache reads=${totalMissionUsage.cache_read_input_tokens}`);
   }
-  if (fs4.existsSync(contextDir)) {
+  if (fs5.existsSync(contextDir)) {
     try {
-      const files = fs4.readdirSync(contextDir);
+      const files = fs5.readdirSync(contextDir);
       for (const file of files) {
         if (file.endsWith(".json") || file.endsWith(".png")) {
-          fs4.unlinkSync(path4.join(contextDir, file));
+          fs5.unlinkSync(path5.join(contextDir, file));
         }
       }
-      fs4.rmSync(contextDir, { recursive: true, force: true });
+      fs5.rmSync(contextDir, { recursive: true, force: true });
       console.log(`>>ARCALITY_STATUS>> \u{1F9F9} Carpeta context eliminada (Memoria ef\xEDmera completada).`);
     } catch (err) {
       console.warn(`No se pudo limpiar la carpeta context: ${err}`);