@arcadialdev/arcality 2.2.0

package/tests/_helpers/agentic-runner.spec.ts

@@ -0,0 +1,741 @@
+import { test, expect } from '@playwright/test';
+import { AIAgentHelper, AgentAction } from './ai-agent-helper';
+import { pushKnowledge, pushRule } from '../../src/services/collectiveMemoryService';
+import 'dotenv/config';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// Cache de reglas ya enviadas en esta ejecución (evita duplicados por el mismo mensaje)
+const _sessionRuleCache = new Set<string>();
+
+/** Guarda un error de validación como regla de negocio (fire-and-forget) */
+function captureValidationRule(errorMessage: string, context: string): void {
+    const key = errorMessage.substring(0, 80).toLowerCase().trim();
+    if (_sessionRuleCache.has(key)) return; // Ya registrado en esta sesión
+    _sessionRuleCache.add(key);
+
+    pushRule({
+        rule_type: 'VALIDATION',
+        title: `Restricción detectada: ${errorMessage.substring(0, 80)}`,
+        description: `La aplicación rechazó la acción con el mensaje: "${errorMessage.substring(0, 300)}". Contexto: ${context.substring(0, 150)}`,
+        severity: 'important'
+    }).catch(() => { /* silencioso */ });
+}
+
+test('Arcality AI Runner', async ({ page }, testInfo) => {
+    test.setTimeout(1200000); // 20 minutos para que la IA local no se corte
+
+    const contextDir = process.env.CONTEXT_DIR || 'out';
+    const activeConfig = process.env.ACTIVE_CONFIG || 'Default';
+
+    if (!process.env.BASE_URL && process.env[`${activeConfig}_URL`]) process.env.BASE_URL = process.env[`${activeConfig}_URL`];
+    if (!process.env.LOGIN_USER && process.env[`${activeConfig}_USER`]) process.env.LOGIN_USER = process.env[`${activeConfig}_USER`];
+    if (!process.env.LOGIN_PASSWORD && process.env[`${activeConfig}_PASS`]) process.env.LOGIN_PASSWORD = process.env[`${activeConfig}_PASS`];
+
+    await page.context().grantPermissions(['geolocation']);
+    await page.context().setGeolocation({ latitude: 19.4326, longitude: -99.1332 });
+
+    const agent = new AIAgentHelper(page, contextDir, testInfo);
+    const prompt = process.env.SMART_PROMPT || "Navega al inicio y verifica que el sitio cargue";
+    const history: string[] = [];
+    const urlHistory: string[] = []; // Para rastrear navegación
+    const stepsData: any[] = []; // Para la Guía de Éxito
+
+    // Keywords Globales para el Test (Refinados para evitar falsos positivos)
+    // 10. DATA CORRECTION: If you try to save/create a record and an [ERROR_CRÍTICO] message appears (e.g., 'duplicado', 'ya existe', 'repetido', 'incorrecto'), you MUST STOP. Analyze which field caused the error, change its value to something unique, and ONLY THEN try to save again.
+    // 11. NEVER IGNORE ERRORS: If you see '🛑 [ERROR_CRÍTICO]', do not assume it will clear upon submission. It is a blocker.
+    // 12. SUCCESS VERIFICATION: If your mission is 'Create X', and you see a success message OR you are back on the list/table view, check if X is there. If so, use 'finish: true'. DO NOT START CREATING AGAIN.
+    // 13. DUPLICATE ACTION: If your history shows multiple clicks on 'Save' without data changes, you are in a loop. CHANGE THE DATA or use 'report_inability_to_proceed'.
+    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|inválido|invalid|incorrecto|incorrect|ligado|linked|depende|depends|duplicado|duplicate|repetido|repeated|reintentar|retry|missing|required|obligatorio|bad request|400|500/i;
+
+    let aiMarkedSuccess = false;
+    let hasCriticalError = false;
+    let resultsSaved = false;
+    let isFinished = false;
+    let stepCount = 0;  // Solo cuenta turnos de IA (no de Guía)
+    let guideStepCount = 0; // Turnos de Guía de Éxito (NO cuentan contra maxSteps)
+    let stepsDataBackup: any[] = []; // Backup para no perder la Guía de Éxito permanentemente
+    const maxSteps = 30; // Aumentado para misiones complejas
+    let lastSeenSuccessToast = ""; // Para evitar falsos positivos por mensajes persistentes
+
+    const saveMissionResults = () => {
+        if (resultsSaved) return;
+        resultsSaved = true;
+
+        if (!fs.existsSync(contextDir)) fs.mkdirSync(contextDir, { recursive: true });
+        const finalSuccess = aiMarkedSuccess && !hasCriticalError;
+
+        try {
+            const memoryFile = path.join(contextDir, 'memoria-agente.json');
+            let memories = [];
+            if (fs.existsSync(memoryFile)) {
+                const content = fs.readFileSync(memoryFile, 'utf8').trim();
+                if (content) {
+                    try {
+                        memories = JSON.parse(content);
+                    } catch (e) {
+                        console.warn("⚠️ Memoria corrupta, reiniciando...");
+                        memories = [];
+                    }
+                }
+            }
+
+            const missionData = {
+                prompt,
+                steps: history,
+                steps_data: stepsData,
+                success: finalSuccess,
+                error: hasCriticalError,
+                timestamp: Date.now()
+            };
+
+            memories.push(missionData);
+            fs.writeFileSync(memoryFile, JSON.stringify(memories, null, 2));
+            console.log(`>>ARCALITY_STATUS>> 🧠 Memoria guardada: ${stepsData.length} pasos nuevos`);
+        } catch (err) {
+            console.error("❌ Falló al guardar memoria:", err);
+        }
+
+        try {
+            const logPath = path.join(contextDir, `agent-log-${Date.now()}.json`);
+            fs.writeFileSync(logPath, JSON.stringify({ prompt, history, steps: stepCount, success: finalSuccess, error: hasCriticalError }, null, 2));
+        } catch (err) { }
+    };
+
+    // ── Persistencia en Memoria Colectiva (se llama desde TODOS los caminos de éxito) ──
+    let collectiveMemoryPersisted = false;
+    const persistCollectiveMemory = async () => {
+        if (collectiveMemoryPersisted) return; // Evitar doble ejecución
+        collectiveMemoryPersisted = true;
+
+        const pid = process.env.ARCALITY_PROJECT_ID || '';
+        const apiUrl = process.env.ARCALITY_API_URL || '';
+        const apiKey = process.env.ARCALITY_API_KEY || '';
+
+        if (!pid || !apiUrl || !apiKey) {
+            console.warn(`[CollectiveMemory] ⚠️ Vars faltantes — project_id='${pid}' api_url='${apiUrl}' api_key='${apiKey ? 'OK' : 'MISSING'}'`);
+            return;
+        }
+
+        console.log(`🧠 [COLLECTIVE MEMORY] Persistiendo conocimiento (project: ${pid})...`);
+        try {
+            const stepsNarrative = stepsData
+                .map(s => `${s.action_data?.action || 'action'} "${s.componentName}" en ${s.url}`)
+                .join(' → ')
+                .substring(0, 500);
+
+            // 1. Flujo completo → PROCESS knowledge
+            const knowledgeId = await pushKnowledge({
+                doc_type: 'PROCESS',
+                title: `Flujo exitoso: ${prompt.substring(0, 100)}`,
+                content: stepsNarrative || prompt.substring(0, 500)
+            });
+            if (knowledgeId) console.log(`🧠 [COLLECTIVE MEMORY] ✅ Knowledge guardado: ${knowledgeId}`);
+            else console.warn(`[CollectiveMemory] ⚠️ pushKnowledge retornó null (revisar HTTP status arriba)`);
+
+            // 2. Patrones de navegación → NAVIGATION rule
+            const uniqueUrls = [...new Set(stepsData.map(s => s.url).filter(Boolean))];
+            if (uniqueUrls.length > 1) {
+                const ruleId = await pushRule({
+                    rule_type: 'NAVIGATION',
+                    title: `Flujo de navegación: ${prompt.substring(0, 80)}`,
+                    description: `Agente navegó ${uniqueUrls.length} páginas: ${uniqueUrls.join(' → ').substring(0, 400)}`,
+                    severity: 'suggestion'
+                });
+                if (ruleId) console.log(`🧠 [COLLECTIVE MEMORY] ✅ Regla NAVIGATION guardada: ${ruleId}`);
+            }
+
+            // 3. Si hubo submit de formulario → UI_UX rule
+            const submitStep = stepsData.find(s =>
+                s.action_data?.action === 'click' &&
+                (s.componentName?.toLowerCase().includes('guardar') ||
+                 s.componentName?.toLowerCase().includes('save') ||
+                 s.componentName?.toLowerCase().includes('crear') ||
+                 s.componentName?.toLowerCase().includes('registrar'))
+            );
+            if (submitStep) {
+                const ruleId2 = await pushRule({
+                    rule_type: 'UI_UX',
+                    title: `Patrón de guardado: ${prompt.substring(0, 60)}`,
+                    description: `Flujo exitoso incluyó guardado/creación. Pasos: ${stepsNarrative.substring(0, 400)}`,
+                    severity: 'important'
+                });
+                if (ruleId2) console.log(`🧠 [COLLECTIVE MEMORY] ✅ Regla UI_UX guardada: ${ruleId2}`);
+            }
+        } catch (err: any) {
+            console.warn(`[CollectiveMemory] ❌ Error inesperado en persistCollectiveMemory: ${err?.message}`);
+        }
+    };
+
+    console.log(`\n🤖 [AGENTE] Iniciando misión: "${prompt}"`);
+
+    // Standard Login
+    const base = process.env.BASE_URL || '';
+    const target = process.env.TARGET_PATH || '/';
+
+    if (process.env.LOGIN_USER && process.env.LOGIN_PASSWORD) {
+        console.log(">>ARCALITY_STATUS>> 🔑 Realizando login automático...");
+        await page.goto(base + '/login');
+        try {
+            const userInp = page.locator('input[type="email"], input[name="email"], input[name="username"], [placeholder*="usuario" i], [placeholder*="correo" i], [placeholder*="email" i]').first();
+            await userInp.waitFor({ state: 'visible', timeout: 10000 });
+
+            const passInp = page.locator('input[type="password"], input[name="password"], [placeholder*="contraseña" i]').first();
+            const subBtn = page.locator('button[type="submit"], button:has-text("Login"), button:has-text("Entrar"), [role="button"]:has-text("Entrar")').first();
+
+            await userInp.click();
+            await userInp.fill(process.env.LOGIN_USER || '');
+            await passInp.click();
+            await passInp.fill(process.env.LOGIN_PASSWORD || '');
+
+            await page.waitForTimeout(500);
+            await subBtn.click();
+
+            // Esperar a que la URL cambie (salir del login)
+            await page.waitForURL(u => !u.href.includes('/login'), { timeout: 15000 }).catch(() => { });
+            await page.waitForLoadState('networkidle').catch(() => { });
+        } catch (e: any) {
+            console.warn(`    ⚠️ Login automático omitido o ya autenticado.`);
+        }
+
+        if (target !== '/' && !page.url().includes(target)) {
+            await page.goto(base + target).catch(() => { });
+        }
+    } else {
+        await page.goto(base + target);
+    }
+    await page.waitForLoadState('networkidle');
+
+    // Global Download Listener
+    page.on('download', async (download) => {
+        aiMarkedSuccess = true;
+        isFinished = true;
+        saveMissionResults();
+    });
+
+    // MAIN LOOP
+    const maxTotalIterations = maxSteps + 50; // Safety: máximo total de iteraciones (IA + Guía)  
+    let totalIterations = 0;
+    while (!isFinished && stepCount < maxSteps) {
+        totalIterations++;
+        if (totalIterations > maxTotalIterations) {
+            console.error(`>>ARCALITY_STATUS>> 🛑 Safety limit: ${totalIterations} iteraciones totales alcanzadas. Abortando.`);
+            hasCriticalError = true;
+            break;
+        }
+        let containsError = false;
+        // stepCount se incrementa MÁS ABAJO, solo si el turno fue de IA (no de Guía)
+        await page.waitForTimeout(1000);
+
+        // --- DETECCIÓN PROACTIVA DE ÉXITO (Prevención de redundancia) ---
+        // Solo se activa tras el Turno 4 Y si ya hubo un submit (ej: guardar/save) en el historial.
+        const currentUrl = page.url();
+        const historyStr = history.join(' ').toLowerCase();
+        const hadSubmitAction = historyStr.includes('guardar') || historyStr.includes('save') || historyStr.includes('registrar');
+        const isMultiStep = prompt.toLowerCase().match(/después|luego|posteriormente|pestaña|tabla|doble clic|arrastra|paso|sección|modal|etapa/i);
+        const allowRepeatedNames = prompt.toLowerCase().match(/modal|varias|distintos|diferentes|repetir|guardar dos veces/i) || isMultiStep;
+
+
+        if (stepCount > 4 && hadSubmitAction && !isMultiStep) {
+            // 1. Chequeo por retorno a lista tras guardar
+            const isNowOnList = !currentUrl.includes('/new') && !currentUrl.includes('/create') && !currentUrl.includes('/edit') && !currentUrl.includes('/details') && !currentUrl.includes('/alta');
+            const wasInForm = historyStr.includes('nueva') || historyStr.includes('crear') || historyStr.includes('alta') || historyStr.includes('/new') || historyStr.includes('/create');
+
+            if (wasInForm && isNowOnList) {
+                // Escanear SOLO elementos pequeños de feedback, no todo el body
+                const feedbackEls = await page.locator('.toast, .alert, [role="status"], [role="alert"], .snackbar, .notification, .success-message, .mat-snack-bar-container').all();
+                let foundSuccessToast = false;
+                for (const el of feedbackEls) {
+                    if (await el.isVisible().catch(() => false)) {
+                        const txt = await el.innerText().catch(() => '');
+                        if (successKeywords.test(txt.toLowerCase())) {
+                            foundSuccessToast = true;
+                            console.log(`>>ARCALITY_STATUS>> ✨ Auto-Success: Toast de éxito detectado: "${txt.substring(0, 60)}"`);
+                            break;
+                        }
+                    }
+                }
+
+                // Si regresamos a la lista Y detectamos un toast de éxito, es éxito.
+                // Ya no confiamos solo en "volver a la lista" para evitar falsos positivos en URLs genéricas.
+                if (foundSuccessToast) {
+                    // Solo es éxito si es un mensaje NUEVO o ha pasado tiempo desde el último submit
+                    console.log(`>>ARCALITY_STATUS>> ✨ Auto-Success: Regreso a lista Y mensaje de éxito detectado.`);
+                    aiMarkedSuccess = true;
+                    isFinished = true;
+                    saveMissionResults();
+                    break;
+                }
+            }
+        }
+
+        // --- LIMPIEZA DE MENSAJES DE STATUS PREEXISTENTES (Login) ---
+        // Si estamos en el primer turno real post-login, registramos mensajes existentes para ignorarlos
+        if (stepCount === 1) {
+            const initialToasts = await page.locator('.toast, .alert, [role="status"], [role="alert"]').all();
+            for (const t of initialToasts) {
+                if (await t.isVisible().catch(() => false)) {
+                    lastSeenSuccessToast = await t.innerText().catch(() => "");
+                    if (lastSeenSuccessToast) console.log(`>>ARCALITY_STATUS>> 💡 Nota: Ignorando mensaje preexistente: "${lastSeenSuccessToast.substring(0, 30)}..."`);
+                }
+            }
+        }
+        // ----------------------------------------------------------------
+
+        // 0. Detectar errores antes de cualquier otra lógica
+        const rawBody = await page.innerText('body').catch(() => "");
+        const bodyTxt = rawBody.toLowerCase();
+        const hasVisibleError = failureKeywords.test(bodyTxt);
+
+        // 1. INTENTAR GUÍA (Solo si NO hay errores visibles)
+        let response: AgentAction | null = null;
+        if (!hasVisibleError) {
+            response = await agent.getActionFromGuia(prompt, stepsData.length);
+        } else {
+            console.log(`>>ARCALITY_STATUS>> ⚠️ Error detectado en pantalla. Saltando Guía para priorizar corrección.`);
+            if (stepsData.length > 0) {
+                stepsDataBackup = [...stepsData]; // Guardar backup antes de invalidar
+                stepsData.length = 0;
+            }
+        }
+
+        if (response) {
+            // GUARD: Invalidate guide if it suggests an action already attempted recently
+            const guideActionDesc = response.actions?.[0]
+                ? `${response.actions[0].action} en "${(response.actions[0] as any).description || ''}"`.toLowerCase()
+                : '';
+            const recentHistory = history.slice(-4).map(h => h.toLowerCase());
+            const isGuideRepeating = guideActionDesc && recentHistory.some(h => h.includes(guideActionDesc.substring(0, 30)));
+
+            if (isGuideRepeating) {
+                console.log(`>>ARCALITY_STATUS>> ⚠️ Guía invalidada: la acción "${guideActionDesc.substring(0, 50)}" ya fue intentada. Delegando a IA.`);
+                response = null; // Force IA to decide
+            } else {
+                guideStepCount++;
+                console.log(`>>ARCALITY_STATUS>> ✨ Guía de éxito: Paso validado (Guía #${guideStepCount}, NO consume turno IA)`);
+            }
+        }
+
+        if (!response) {
+            // 2. CONSULTAR IA — ESTE turno SÍ cuenta contra maxSteps
+            stepCount++;
+            console.log(`>>ARCALITY_STATUS>> ⏳ Turno IA ${stepCount} de ${maxSteps} (Guía usó ${guideStepCount} turnos gratis)...`);
+            response = await agent.askIA(prompt, history);
+        }
+
+        console.log(`🧠 Pensamiento: ${response.thought}`);
+
+        // DETECCIÓN DE LOOPS: Si las últimas 6 acciones muestran un patrón repetitivo, forzar terminación
+        if (!response.finish && history.length >= 6) {
+            const lastSixActions = history.slice(-6);
+            const clickActions = lastSixActions.filter(h => h.includes('click en'));
+            const fillActions = lastSixActions.filter(h => h.includes('fill en'));
+            const uniqueClicks = new Set(clickActions);
+            const uniqueFills = new Set(fillActions);
+
+            // Si hay 4+ clicks y solo 1-2 elementos únicos = LOOP DETECTADO
+            const isClickLoop = clickActions.length >= 4 && uniqueClicks.size <= 2;
+            // NEW: Si hay 4+ fills y solo 1-2 elementos únicos = LOOP DETECTADO (time picker pattern)
+            const isFillLoop = fillActions.length >= 4 && uniqueFills.size <= 2;
+
+            if (isClickLoop || isFillLoop) {
+                const loopType = isClickLoop ? 'click' : 'fill';
+                const uniqueTargets = isClickLoop ? uniqueClicks : uniqueFills;
+                console.warn(`\n⚠️ [LOOP DETECTOR] Patrón repetitivo de ${loopType} detectado:`);
+                console.warn(`   Últimas acciones: ${lastSixActions.join(' → ')}`);
+                console.warn(`   El agente está atrapado. Forzando terminación con sugerencia.`);
+
+                response.thought = `🛑 ERROR: Me he quedado atrapado en un bucle repetitivo intentando interactuar con: ${Array.from(uniqueTargets).join(', ')}. No puedo continuar la misión de forma autónoma.\n\n💡 REGLA DE QA: He detectado que mi acción de ${loopType} no está cambiando el estado de la página como esperaba. Esto podría ser un bug de la aplicación o una limitación de mi percepción actual.`;
+                response.finish = true;
+                response.actions = [];
+                aiMarkedSuccess = false;
+                hasCriticalError = true;
+            }
+        }
+
+        if (response.actions && response.actions.length > 0) {
+            for (const step of response.actions) {
+                console.log(`>>ARCALITY_STATUS>> 🎯 Acción: ${step.action} en "${(step as any).description || step.selector}"`);
+
+                try {
+                    const frame = (step.frameIdx !== undefined && page.frames()[step.frameIdx]) ? page.frames()[step.frameIdx] : page;
+                    const loc = step.selector ? frame.locator(step.selector).first() : null;
+
+                    const urlBeforeAction = page.url(); // CAPTURA ANTES DE ACCIÓN
+
+                    if ((step.action === 'click' || step.action === 'double_click') && loc) {
+                        const desc = ((step as any).description || '').toLowerCase();
+                        const isMenuTrigger = desc.includes('more_vert') || desc.includes('menu') || desc.includes('icono :') || desc.includes('dots') || desc.includes('opciones');
+
+                        // PROFUNDO: BLOQUEO DE DOBLE-SUBMIT
+                        // Si ya hicimos click en "Guardar" antes, NO LO VOLVEMOS A HACER. Asumimos que la IA está confundida o verificando.
+                        const isSubmitAction = desc.includes('guardar') || desc.includes('save') || desc.includes('crear') || desc.includes('registrar') || desc.includes('enviar') || desc.includes('aceptar') || desc.includes('confirmar') || desc.includes('update');
+                        if (isSubmitAction) {
+                            // Semantic boost for critical feedback
+                            const rawBodyText = await page.innerText('body').catch(() => "");
+                            const textLower = rawBodyText.toLowerCase();
+                            const isCriticalFailure = textLower.includes('error') || textLower.includes('falló') || textLower.includes('no se puede') || textLower.includes('ya existe') || textLower.includes('existe') || textLower.includes('inválido') || textLower.includes('incorrecto') || textLower.includes('ligado') || textLower.includes('depende') || textLower.includes('duplicado') || textLower.includes('repetido') || textLower.includes('no encontrado') || textLower.includes('no existe') || textLower.includes('obligatorio') || textLower.includes('required');
+                            const isCriticalSuccess = textLower.includes('exitosamente') || textLower.includes('guardado') || textLower.includes('creado') || textLower.includes('success') || textLower.includes('correctamente') || textLower.includes('misión cumplida');
+                            const isCriticalFeedback = isCriticalFailure || isCriticalSuccess;
+
+                            // Priorizar la detección de fallos/éxitos en elementos pequeños que la IA podría ignorar
+                            if (!isCriticalFeedback && (step as any).type && ['span', 'p', 'label', 'i', 'svg', 'img'].includes((step as any).type)) {
+                                const elementText = await loc.innerText().catch(() => "");
+                                const elementTextLower = elementText.toLowerCase();
+                                if (failureKeywords.test(elementTextLower)) {
+                                    console.log(`>>ARCALITY_STATUS>> ⚠️ Feedback de ERROR en elemento pequeño: "${elementTextLower.substring(0, 50)}..."`);
+                                    aiMarkedSuccess = false;
+                                    // If a critical error is detected on a small element, it's a strong signal.
+                                    // We should consider this a critical error for the mission.
+                                    hasCriticalError = true;
+                                    isFinished = true;
+                                    saveMissionResults();
+                                    break; // Break out of the actions loop
+                                } else {
+                                    const isSuccessMatch = successKeywords.test(elementTextLower);
+                                    if (isSuccessMatch) {
+                                        console.log(`>>ARCALITY_STATUS>> ✨ Éxito visual en elemento pequeño: "${elementTextLower.substring(0, 50)}..."`);
+                                        aiMarkedSuccess = true;
+                                        isFinished = true;
+                                        hasCriticalError = false;
+                                        saveMissionResults();
+                                        break;
+                                    }
+                                }
+                            }
+
+                            const previousSubmit = history.find(h =>
+                                h.toLowerCase().includes('click') &&
+                                (h.toLowerCase().includes('guardar') || h.toLowerCase().includes('save') || h.toLowerCase().includes('crear') || h.toLowerCase().includes('registrar'))
+                            );
+
+                            if (previousSubmit && !allowRepeatedNames) {
+                                console.log(`>>ARCALITY_STATUS>> 🛑 Advertencia: Click persistente en botón de acción.`);
+                                // No matamos el test, solo notificamos al agente en su historia para que lo vea
+                                history.push(`Turno ${stepCount}: Intentaste hacer click en "${desc}" nuevamente, pero la página sigue mostrando el mismo estado. ¿Hay algún error visible que debas corregir antes?`);
+                                await page.waitForTimeout(1000);
+                            }
+                        }
+
+                        // PROFUNDO: BLOQUEO DE DOBLE-CLICK CONSECUTIVO
+                        // Si la acción anterior fue exactamente la misma (mismo elemento), y no hubo un cambio significativo, lo bloqueamos.
+                        const lastAction = history[history.length - 1];
+                        if (lastAction && lastAction.includes(`click en "${desc}"`)) {
+                            const isDotsTrigger = desc.includes('dots') || desc.includes('vert') || desc.includes('menu') || desc.includes('opciones');
+                            const sameActionCount = history.filter(h => h.includes(`click en "${desc}"`)).length;
+
+                            // Si el prompt permite repeticiones (ej. multi-step con varios 'Guardar'), somos más tolerantes
+                            const toleranceLimit = allowRepeatedNames ? 3 : 1;
+
+                            if (isDotsTrigger && sameActionCount < 2) {
+                                console.log(`    ⚠️ Re-intentando click en menú "${desc}"...`);
+                            } else if (allowRepeatedNames && sameActionCount < toleranceLimit) {
+                                console.log(`    ⚠️ Click repetido permitido por contexto de misión en "${desc}"...`);
+                            } else {
+                                // FALLBACK: Si estamos estancados, ¿quizás el error ya es visible en algun post?
+                                const bodyText = await page.innerText('body').catch(() => "");
+                                if (bodyText.match(/ligado|depende|no se puede/i)) {
+                                    console.log(`\n✨ [ESTANCADO] El agente repite click pero el error ya es visible. Finalizando.`);
+                                    isFinished = true;
+                                    aiMarkedSuccess = true;
+                                    break;
+                                }
+                                console.log(`\n🛑 [AUTO-STOP] Bloqueando click duplicado en "${desc}". Forzando re-evaluación.`);
+                                history.push(`Turno ${stepCount}: Bloqueado click repetido en "${desc}" (Evitando bucle)`);
+                                await page.waitForTimeout(1000);
+                                break;
+                            }
+                        }
+
+                        if (isMenuTrigger && history.some(h => h.includes(desc) && h.includes('click'))) {
+                            console.log(`    ⚠️ El disparador "${desc}" ya fue clicado. Esperando estabilidad extra...`);
+                            await page.waitForTimeout(1500);
+                        }
+
+                        await loc.scrollIntoViewIfNeeded({ timeout: 5000 }).catch(() => { });
+
+                        if (step.action === 'double_click') {
+                            await loc.dblclick({ timeout: 10000, force: true });
+                        } else {
+                            // HACK: Si es cerrar toast y falla, ignoramos
+                            if (desc.includes('toast') || desc.includes('close')) {
+                                await loc.click({ timeout: 2000, force: true }).catch(() => console.log("    ⚠️ No se pudo cerrar toast, ignorando..."));
+                            } else {
+                                await loc.click({ timeout: 10000, force: true });
+                            }
+                        }
+
+                        if (isMenuTrigger) {
+                            console.log("    ⏳ Abriendo menú, esperando 1.5s para renderizado...");
+                            await page.waitForTimeout(1500);
+                        }
+
+                        // INTELIGENCIA DE FINALIZACIÓN POST-GUARDADO
+                        // Si la acción fue "Guardar" o "Crear", verificamos si hubo navegación exitosa
+                        const actsLikeSubmit = desc.includes('guardar') || desc.includes('save') || desc.includes('crear') || desc.includes('registrar');
+
+                        if (actsLikeSubmit) {
+                            console.log("    ⏳ Esperando transición post-guardado...");
+                            try {
+                                await page.waitForLoadState('networkidle', { timeout: 8000 });
+                            } catch (e) { console.log("    ⚠️ Timeout esperando red, continuando..."); }
+
+                            // 1. CHEQUEO POR VISUALIZACIÓN DE ÉXITO Y ERRORES (Solo Toasts/Alertas)
+                            const postSubmitFeedback = await page.locator('.toast, .alert, [role="status"], [role="alert"], .snackbar, .notification, .success-message, .mat-snack-bar-container').all();
+                            let foundSuccessPost = false;
+                            for (const fb of postSubmitFeedback) {
+                                if (await fb.isVisible().catch(() => false)) {
+                                    const fbText = await fb.innerText().catch(() => '');
+                                    const postSuccessKw = /exitosamente|creado correctamente|guardado correctamente|operación exitosa|registro guardado|saved successfully|created successfully/i;
+                                    if (postSuccessKw.test(fbText)) {
+                                        console.log(`>>ARCALITY_STATUS>> ✨ Éxito visual detectado en toast: "${fbText.substring(0, 60)}"`);
+                                        aiMarkedSuccess = true;
+                                        isFinished = true;
+                                        saveMissionResults();
+                                        foundSuccessPost = true;
+                                        break;
+                                    } else if (failureKeywords.test(fbText.toLowerCase())) {
+                                        // ⭐ ERROR DE VALIDACIÓN DE NEGOCIO — Guardar como regla
+                                        console.log(`>>ARCALITY_STATUS>> 📚 [BUSINESS RULE] Error de validación capturado: "${fbText.substring(0, 80)}"`);
+                                        captureValidationRule(fbText.trim(), `Acción: click en "${desc}" en ${page.url()}`);
+                                    }
+                                }
+                            }
+                            if (foundSuccessPost) break;
+
+
+                            // 2. CHEQUEO POR CAMBIO DE URL (Backup)
+                            const currentUrl = page.url();
+                            const isBackOnList = urlBeforeAction !== currentUrl && !currentUrl.includes('/new') && !currentUrl.includes('/edit') && !currentUrl.includes('/create');
+
+                            if (isBackOnList) {
+                                console.log(`\n✨ [AUTO-SUCCESS] Navegación detectada tras guardar (${urlBeforeAction} -> ${currentUrl}). Confirmando...`);
+                                await page.waitForTimeout(2000);
+
+                                const postNavAlerts = await page.locator(
+                                    '.toast, .alert, [role="status"], [role="alert"], .snackbar, .notification, .error-message, .mat-snack-bar-container'
+                                ).all();
+                                let hasPostNavError = false;
+                                for (const alertEl of postNavAlerts) {
+                                    if (await alertEl.isVisible().catch(() => false)) {
+                                        const alertTxt = await alertEl.innerText().catch(() => '');
+                                        if (failureKeywords.test(alertTxt.toLowerCase())) {
+                                            hasPostNavError = true;
+                                            console.log(`>>ARCALITY_STATUS>> ⚠️ Error en alerta post-guardado: "${alertTxt.substring(0, 60)}"`);
+                                            break;
+                                        }
+                                    }
+                                }
+
+                                if (!hasPostNavError) {
+                                    aiMarkedSuccess = true;
+                                    isFinished = true;
+                                    await persistCollectiveMemory(); // ← Persistir en TODOS los caminos de éxito
+                                    saveMissionResults();
+                                    break;
+                                } else {
+                                    console.log(`>>ARCALITY_STATUS>> ⚠️ Se detectó navegación pero hay un ERROR en alerta/toast visible.`);
+                                }
+                            }
+                        } else if (desc.includes('siguiente') || desc.includes('next')) {
+                            await page.waitForTimeout(1000);
+                        } else {
+                            await page.waitForTimeout(500); // Click normal, espera corta
+                        }
+                    }
+                    else if (step.action === 'fill' && loc && step.value) {
+                        // DETECCIÓN INTELIGENTE DE INPUT FILE
+                        const isFile = await loc.evaluate((el: any) => el.tagName === 'INPUT' && el.type === 'file').catch(() => false);
+
+                        if (isFile) {
+                            console.log(`    📂 Detectado input de archivo. Subiendo: "${step.value}"`);
+                            const filePath = step.value.replace(/^"|"$/g, '').trim(); // Limpiar comillas si la IA las puso
+                            await loc.setInputFiles(filePath);
+                        } else {
+                            await loc.click({ timeout: 5000 }).catch(() => { });
+                            await loc.fill(step.value, { timeout: 10000, force: true });
+                            await loc.press('Tab').catch(() => { }); // Disparar validaciones/change events
+                        }
+                        await page.waitForTimeout(500); // Dar un respiro a la UI
+                    }
+                    else if (step.action === 'wait') {
+                        await page.waitForTimeout(3000);
+                    }
+
+                    // Registrar en historial para la IA
+                    const descForHistory = ((step as any).description || step.selector || '').substring(0, 80);
+                    const valStr = step.value ? ` con valor "${step.value}"` : '';
+                    history.push(`Turno ${stepCount}: ${step.action} en "${descForHistory}"${valStr}`);
+                    urlHistory.push(page.url());
+
+                    // Registrar en Guía de Éxito (solo si el componente tiene un nombre razonable)
+                    const compName = ((step as any).description || '').substring(0, 80);
+                    if (compName.length < 100) { // Skip guide storage for misidentified giant text blobs
+                        stepsData.push({
+                            url: urlBeforeAction, // USAR URL CAPTURADA ANTES
+                            componentName: compName,
+                            componentType: (step as any).type,
+                            action_data: { action: step.action, value: step.value },
+                            finish: response.finish
+                        });
+                    }
+
+                } catch (e: any) {
+                    console.warn(`  ⚠️ Acción fallida: ${e.message}`);
+                    history.push(`Turno ${stepCount}: ❌ FALLÓ ${step.action} en "${(step as any).description}" - Error: ${e.message}. REGLA MANDATORIA: Debes investigar la causa usando 'inspect_element_details' o 'capture_console_errors' antes de cualquier otro paso.`);
+                    containsError = true;
+
+                    // Solo matamos si el error es persistente para evitar bucles infinitos
+                    const errorCount = history.filter(h => h.includes('FALLÓ') && h.includes((step as any).description)).length;
+                    if (errorCount >= 2) {
+                        console.error(`>>ARCALITY_STATUS>> 🛑 Demasiados fallos técnicos en este elemento "${(step as any).description}". Abortando misión.`);
+                        hasCriticalError = true;
+                        isFinished = true;
+                        break;
+                    }
+                }
+            }
+        }
+
+        // SOLO permitimos finalizar si no hubo errores técnicos en este turno
+        if (response.finish) {
+            if (!containsError) {
+                console.log(">>ARCALITY_STATUS>> ✅ El agente solicitó finalizar misión.");
+                isFinished = true;
+                
+                // --- REGISTRO DEL PASO FINAL EN LA GUÍA DE ÉXITO ---
+                // Si el agente termina sin acciones (ej. vía create_test_evidence), registramos un paso implícito
+                // para que la guía sepa que aquí debe terminar en futuras ejecuciones.
+                if (!response.actions || response.actions.length === 0) {
+                    stepsData.push({
+                        url: page.url(),
+                        componentName: "MISSION_END",
+                        componentType: "FINISH_SIGNAL",
+                        action_data: { action: 'finish' },
+                        finish: true
+                    });
+                } else {
+                    // Si hubo acciones, nos aseguramos que la última tenga el flag 'finish'
+                    if (stepsData.length > 0) {
+                        stepsData[stepsData.length - 1].finish = true;
+                    }
+                }
+
+                // Verificar solo en toasts/alertas VISIBLES, NO en el body completo
+                const finishFeedbackEls = await page.locator('.toast, .alert, [role="status"], [role="alert"], .snackbar, .notification, .mat-snack-bar-container, .error-message').all();
+                let hasVisibleFailure = false;
+                for (const el of finishFeedbackEls) {
+                    if (await el.isVisible().catch(() => false)) {
+                        const txt = await el.innerText().catch(() => '');
+                        if (failureKeywords.test(txt.toLowerCase())) {
+                            hasVisibleFailure = true;
+                            console.log(`>>ARCALITY_STATUS>> ⚠️ Error detectado en toast/alerta: "${txt.substring(0, 60)}"`);
+                            break;
+                        }
+                    }
+                }
+
+                if (!hasVisibleFailure) {
+                    // Marcar éxito: el agente pidió finish y no hay errores visibles
+                    aiMarkedSuccess = true;
+                    hasCriticalError = false;
+                    
+                    // Guardar resultados proactivamente antes de que Playwright cierre el contexto
+                    saveMissionResults();
+
+                    // Restaurar stepsData si fue invalidada pero la misión se recuperó
+                    if (stepsData.length === 0 && stepsDataBackup.length > 0) {
+                        stepsData.push(...stepsDataBackup);
+                        console.log(`>>ARCALITY_STATUS>> 🔄 Guía de Éxito restaurada (${stepsDataBackup.length} pasos recuperados).`);
+                    }
+                    await persistCollectiveMemory(); // ← camino: response.finish sin error
+                } else {
+                    console.log(`>>ARCALITY_STATUS>> ⚠️ El agente intentó finalizar pero se detectó un ERROR en alert/toast.`);
+                    aiMarkedSuccess = false;
+                    isFinished = false; // Forzar a que el agente vea el error
+                    history.push(`Turno ${stepCount}: El agente intentó finalizar pero el sistema detectó un error en un toast/alerta visible.`);
+                }
+            } else {
+                console.warn(">>ARCALITY_STATUS>> ⚠️ El agente intentó finalizar pero hubo fallos en el turno. Continuando para investigación...");
+                isFinished = false;
+            }
+        }
+
+        // Auto-detección por feedback visual (Toasts, Alertas, o mensajes de estado)
+        const feedbackSelector = '.toast, .alert, .message, div[role="status"], .error-message, [class*="alert"], [class*="toast"], .status-message';
+        const feedbackLocator = page.locator(feedbackSelector);
+
+        // Solo autodetectar si estamos más allá del Turno 2
+        if (stepCount > 2) {
+            const allFeedback = await feedbackLocator.all();
+            for (const fb of allFeedback) {
+                if (await fb.isVisible()) {
+                    const rawTxt = await fb.innerText();
+                    const txt = rawTxt.toLowerCase();
+
+                    if (failureKeywords.test(txt)) {
+                        console.log(`>>ARCALITY_STATUS>> ⚠️ Feedback de ERROR detectado: "${rawTxt.substring(0, 60)}..."`);
+                        aiMarkedSuccess = false;
+
+                        // ⭐ ERROR DE VALIDACIÓN / NEGOCIO — Guardar como regla de dominio
+                        captureValidationRule(rawTxt.trim(), `URL: ${page.url()}`);
+
+                        // CRÍTICO: Si detectamos un error, invalidamos la Guía de Éxito para este run
+                        if (stepsData.length > 0) {
+                            console.log(`>>ARCALITY_STATUS>> 🔄 Invalidando Guía de Éxito por feedback de error.`);
+                            stepsDataBackup = [...stepsData]; // Guardar backup
+                            stepsData.length = 0;
+                        }
+                    }
+                    else if (successKeywords.test(txt)) {
+                        if (txt !== lastSeenSuccessToast) {
+                            console.log(`>>ARCALITY_STATUS>> ✨ Éxito visual detectado: "${txt.substring(0, 50)}..."`);
+                            aiMarkedSuccess = true;
+                            isFinished = true;
+                            hasCriticalError = false;
+                            await persistCollectiveMemory(); // ← camino: toast de éxito
+                            saveMissionResults();
+                            break;
+                        } else {
+                            console.log(`>>ARCALITY_STATUS>> 💡 Mensaje de éxito persistente ignorado.`);
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    if (aiMarkedSuccess) {
+        hasCriticalError = false;
+        // Si no se persistió aún (ej. ningún camino early de success lo hizo), persistir ahora
+        await persistCollectiveMemory();
+
+        console.log("✍️ [HUMANIZANDO] Generando resumen de éxito para el reporte...");
+        const summary = await agent.humanizeMissionResult(prompt, history);
+        if (summary) {
+            await testInfo.attach('success_summary', {
+                body: Buffer.from(summary, 'utf-8'),
+                contentType: 'text/plain'
+            });
+        }
+
+        console.log("🤖 [SMART-YAML] Generating mission card...");
+        const smartYaml = await agent.summarizeMissionToYaml(prompt, history, target);
+        if (smartYaml) {
+            const yamlPath = path.join(contextDir, 'last-mission-smart.yaml');
+            fs.writeFileSync(yamlPath, smartYaml);
+            console.log(`>>ARCALITY_STATUS>> 📝 Smart Mission Card generated.`);
+            await testInfo.attach('smart_mission_card', {
+                body: Buffer.from(smartYaml, 'utf-8'),
+                contentType: 'text/yaml'
+            });
+        }
+    }
+
+    saveMissionResults();
+
+    if (!aiMarkedSuccess) {
+        throw new Error("Misión no completada o finalizada con errores.");
+    }
+});