@arcadialdev/arcality 2.2.0

package/tests/_helpers/ai-agent-helper.ts

@@ -0,0 +1,1573 @@
+import { Page, TestInfo } from '@playwright/test';
+import { qaAdvancedTools } from './qa-tools';
+import chalk from 'chalk';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as crypto from 'crypto';
+import { KnowledgeService, PortalIngestRequest, PortalContextResponse } from '../../src/KnowledgeService';
+import { pushField, getKnownFieldIdentifiers } from '../../src/services/collectiveMemoryService';
+
+// Caché por sesión: fields ya enviados en esta ejecución del test (no persistente, solo RAM)
+const _sessionFieldCache = new Set<string>();
+
+export interface PageState {
+    url: string;
+    title: string;
+    components: any[];
+}
+
+export interface SingleAction {
+    idx?: number;
+    action: 'click' | 'double_click' | 'fill' | 'select' | 'wait';
+    selector?: string;
+    value?: string;
+    frameIdx?: number;
+    description?: string; // Nombre del componente
+    type?: string;        // Tipo del componente (FIELD, ACTION, etc)
+}
+
+export interface AgentAction {
+    thought: string;
+    actions: SingleAction[];
+    finish?: boolean;
+}
+
+/**
+ * AIAgentHelper: Gestiona percepción (DOM + Visión) y el motor cognitivo de Arcality.
+ */
+export class AIAgentHelper {
+    private page: Page;
+    private contextDir: string;
+    private testInfo?: TestInfo;
+    private knowledgeService: KnowledgeService;
+
+    private lastScreenshot: string | null = null;
+    private logs: string[] = [];
+    private checkpoints: Map<string, { url: string; storageState: any; localStorage: Record<string, string>; sessionStorage: Record<string, string> }> = new Map();
+    private sessionStorage: Map<string, string> = new Map();
+
+    constructor(page: Page, contextDir: string = 'out', testInfo?: TestInfo, knowledgeService?: KnowledgeService) {
+        this.page = page;
+        this.contextDir = contextDir;
+        this.testInfo = testInfo;
+        this.knowledgeService = knowledgeService || KnowledgeService.getInstance();
+
+        // Track console logs and network errors for QA context
+        this.page.on('console', msg => {
+            if (msg.type() === 'error' || msg.type() === 'warning') {
+                this.logs.push(`[${msg.type().toUpperCase()}] ${msg.text()}`);
+                if (this.logs.length > 30) this.logs.shift();
+            }
+        });
+
+        this.page.on('requestfailed', request => {
+            const failure = request.failure();
+            this.logs.push(`[NETWORK_ERROR] ${request.method()} ${request.url()} - ${failure?.errorText || 'Unknown error'}`);
+            if (this.logs.length > 30) this.logs.shift();
+        });
+    }
+
+    private loadSkills(): string {
+        try {
+            let skillsContext = "";
+            let loadedCount = 0;
+
+            const toolsRoot = process.env.ARCALITY_ROOT || path.join(__dirname, '..', '..');
+            const possibleDirs = [
+                path.join(toolsRoot, '.agent', 'skills'),
+                path.join(toolsRoot, '.agents', 'skills')
+            ];
+
+            for (const rootDir of possibleDirs) {
+                if (!fs.existsSync(rootDir)) continue;
+
+                if (loadedCount === 0) {
+                    skillsContext += "\n🛠️ SKILLS INSTALADAS (Metodologías activas):\n";
+                }
+
+                const entries = fs.readdirSync(rootDir, { withFileTypes: true });
+
+                for (const entry of entries) {
+                    let content = "";
+                    let skillName = entry.name;
+
+                    if (entry.isDirectory()) {
+                        // Look for SKILL.md in the subdirectory
+                        const skillPath = path.join(rootDir, entry.name, 'SKILL.md');
+                        if (fs.existsSync(skillPath)) {
+                            content = fs.readFileSync(skillPath, 'utf8');
+                        }
+                    } else if (entry.name.endsWith('.md')) {
+                        // Flat .md file at the root of skills/
+                        const skillPath = path.join(rootDir, entry.name);
+                        content = fs.readFileSync(skillPath, 'utf8');
+                    }
+
+                    if (content) {
+                        skillsContext += `\n--- SKILL: ${skillName} ---\n${content}\n`;
+                        loadedCount++;
+                    }
+                }
+            }
+
+            if (loadedCount > 0) {
+                console.log(`>> 📑 ${loadedCount} habilidades QA inyectadas al cerebro.`);
+                return skillsContext;
+            }
+        } catch (e: any) {
+            console.warn(`>>ARCALITY_STATUS>> ⚠️ Error cargando habilidades: ${e.message}`);
+        }
+        return "";
+    }
+
+    private loadMemory(prompt: string): string {
+        try {
+            const memoryFile = path.join(this.contextDir, 'memoria-agente.json');
+            if (fs.existsSync(memoryFile)) {
+                const memories = JSON.parse(fs.readFileSync(memoryFile, 'utf8'));
+
+                // Extraer palabras clave del prompt actual
+                const keywords = prompt.toLowerCase().split(' ').filter(w => w.length > 4);
+
+                // Filtrar solo memorias EXITOSAS y SEMÁNTICAMENTE RELEVANTES
+                const relevantSuccess = memories
+                    .filter((m: any) => {
+                        if (!m.success) return false;
+                        const memPrompt = (m.prompt || '').toLowerCase();
+                        // Al menos 3 palabras clave deben coincidir o ser muy similares
+                        const matches = keywords.filter(kw => memPrompt.includes(kw)).length;
+                        return matches >= 3 || (keywords.length > 0 && matches === keywords.length);
+                    })
+                    .slice(-1); // Solo el MÁS reciente
+
+                const relevantFailures = memories
+                    .filter((m: any) => !m.success && m.error)
+                    .slice(-1); // Solo el más reciente
+
+                let memoryContext = "";
+                if (relevantSuccess.length) {
+                    const best = relevantSuccess[0];
+                    memoryContext += `\n📚 SUCCESS GUIDANCE FOR THIS MISSION:
+The following steps led to SUCCESS for a similar mission ("${best.prompt}"):
+${best.steps.slice(0, 15).map((s: any) => `  - ${s}`).join('\n')}
+(Use these steps as a roadmap if the current UI allows it!)
+`;
+                }
+                if (relevantFailures.length) {
+                    memoryContext += `\n⚠️ PREVIOUS FAILURES TO AVOID:\n${relevantFailures.map((m: any) => `- ${m.prompt}`).join('\n')}\n`;
+                }
+                return memoryContext;
+            }
+        } catch { }
+        return "";
+    }
+
+    async getPageState(): Promise<PageState> {
+        if (this.page.isClosed()) return { url: '', title: '', components: [] };
+        return this.getPageStateRefined();
+    }
+
+    private async getPageStateRefined(): Promise<PageState> {
+        const frames = this.page.frames();
+        let globalIdx = 0;
+        const allComponents: any[] = [];
+
+        for (let fIdx = 0; fIdx < frames.length; fIdx++) {
+            const frame = frames[fIdx];
+            if (frame.isDetached()) continue;
+            try {
+                const results = await frame.evaluate(({ startIdx }) => {
+                    const isVisible = (el: HTMLElement) => {
+                        const style = window.getComputedStyle(el);
+                        const rect = el.getBoundingClientRect();
+                        const hasSize = rect.width > 1 && rect.height > 1;
+                        const isNotTranslucent = parseFloat(style.opacity || '1') > 0.05;
+                        const isCssVisible = style.display !== 'none' && style.visibility !== 'hidden';
+                        return isCssVisible && isNotTranslucent && hasSize;
+                    };
+
+                    const nodes = Array.from(document.querySelectorAll('button, input, select, textarea, [role], a, h1, h2, label, span, p, i, svg, img, [class*="alert"],[class*="toast"],[class*="message"],[class*="error"],[class*="success"],[id*="alert"],[id*="toast"],[role="alert"],[role="status"],.error-message,.success-message'));
+                    let localCount = 0;
+
+                    return nodes
+                        .filter(el => {
+                            const htmlEl = el as HTMLElement;
+                            // SPECIAL RULE: File inputs are often invisible but interactable via Playwright.
+                            if (htmlEl.tagName.toLowerCase() === 'input' && (htmlEl as HTMLInputElement).type === 'file') {
+                                return window.getComputedStyle(htmlEl).display !== 'none';
+                            }
+                            return isVisible(htmlEl);
+                        })
+                        .map(el => {
+                            const htmlEl = el as HTMLElement;
+                            const tag = htmlEl.tagName.toLowerCase();
+                            const role = htmlEl.getAttribute('role') || '';
+                            const text = (htmlEl.innerText || htmlEl.getAttribute('aria-label') || htmlEl.getAttribute('title') || '').trim().replace(/\s+/g, ' ');
+
+                            const textLower = text.toLowerCase();
+                            // Semantic boost for critical feedback
+                            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')) && (text.length < 200);
+                            const isCriticalSuccess = (textLower.includes('exitosamente') || textLower.includes('guardado') || textLower.includes('creado') || textLower.includes('success') || (textLower.includes('correctamente') && text.length < 100)) && (text.length < 200);
+                            const isCriticalFeedback = isCriticalFailure || isCriticalSuccess;
+
+                            if (!isCriticalFeedback && (tag === 'span' || tag === 'p' || tag === 'label' || tag === 'i' || tag === 'svg' || tag === 'img' || tag === 'div')) {
+                                const hasIdentification = htmlEl.hasAttribute('aria-label') || htmlEl.hasAttribute('title') || role || htmlEl.id;
+                                // Filtrar contenedores gigantes de texto que confunden a la IA (Blobs de ruido)
+                                if (text.length > 300 && !isCriticalFeedback && !hasIdentification) return null;
+                                if (text.length < 2 && !hasIdentification && tag !== 'svg' && tag !== 'img' && tag !== 'i') return null;
+                            }
+
+                            const idx = startIdx + localCount++;
+                            htmlEl.setAttribute('agent-idx', idx.toString());
+
+                            let name = text || htmlEl.getAttribute('aria-label') || htmlEl.getAttribute('title') || htmlEl.getAttribute('placeholder');
+
+                            // Contextual search for unnamed elements (Icons, Action buttons)
+                            if (!name) {
+                                // 1. Proactive Icon detection (Move this UP)
+                                const iconMatch = htmlEl.outerHTML.match(/fa-([a-z0-9-]+)|md-([a-z0-9-]+)|bi-([a-z0-9-]+)/i);
+                                if (iconMatch) {
+                                    name = `Icon:${iconMatch[1] || iconMatch[2] || iconMatch[3]}`;
+                                }
+                            }
+
+                            const htmlLower = htmlEl.outerHTML.toLowerCase();
+                            const classLower = (htmlEl.className || '').toString().toLowerCase();
+
+                            // Semantic Action Detection
+                            const isDeleteAction = htmlLower.includes('trash') || htmlLower.includes('delete') || htmlLower.includes('eliminar') || htmlLower.includes('remove');
+                            const isEditAction = htmlLower.includes('edit') || htmlLower.includes('pencil') || htmlLower.includes('modify') || htmlLower.includes('editar') || htmlLower.includes('modificar') || htmlLower.includes('pen');
+
+                            if (isDeleteAction && (!name || name.length < 3)) name = '[INFERRED] Eliminar';
+                            if (isEditAction && (!name || name.length < 3)) name = '[INFERRED] Editar';
+
+                            let type = 'INFO';
+                            const isErrorClass = classLower.includes('error') || classLower.includes('danger') || classLower.includes('fail');
+                            // Strict constraint: to be considered an error strictly by CSS class, it must have > 2 words (a real message) or not be a label.
+                            const isError = isCriticalFailure || (isErrorClass && text.split(' ').length > 2);
+                            const isSuccess = classLower.includes('success') || isCriticalSuccess || textLower.includes('éxito');
+
+                            const isTab = role === 'tab' || classLower.includes('tab') || classLower.includes('pestaña');
+
+                            if (tag === 'input' || tag === 'textarea' || tag === 'select') type = 'FIELD';
+                            else if (tag === 'button' || role === 'button' || tag === 'a' || role === 'link' || isTab) type = 'ACTION';
+                            else if (role === 'option') type = 'OPTION';
+                            else if (role === 'combobox' || htmlEl.hasAttribute('aria-expanded')) type = 'DROPDOWN';
+                            else if (isError || classLower.includes('alert') || classLower.includes('toast') || role === 'status' || role === 'alert' || isCriticalFeedback) {
+                                type = isSuccess ? 'SUCCESS_MESSAGE' : (isError ? 'ERROR_MESSAGE' : 'MESSAGE');
+                            }
+
+                            if (type.includes('MESSAGE')) {
+                                const prefix = isError ? '🛑 [ERROR_CRÍTICO] ' : (isSuccess ? '✨ [ÉXITO_DETECTADO] ' : '[INFO] ');
+                                name = prefix + (name || text || 'Mensaje del sistema');
+                            }
+
+                            // Add tag context and row context for small names
+                            if (type === 'ACTION' || type === 'FIELD') {
+                                name = `[${tag}] ${name || ''}`.trim();
+                                if (!name || name.length < 10) {
+                                    const row = htmlEl.closest('tr');
+                                    if (row) {
+                                        const rowText = (row.innerText || '').split('\n')[0].substring(0, 20).trim();
+                                        if (rowText) name += ` (${rowText})`;
+                                    }
+                                }
+                            }
+
+                            if (!name) name = tag;
+
+                            let score = 10;
+                            if (type === 'MESSAGE') score = 200; // Prioridad máxima para leer feedback
+                            else if (type === 'FIELD') score = 100;
+                            else if (type === 'OPTION') score = 90;
+                            else if (type === 'ACTION') score = 80;
+                            else if (type === 'DROPDOWN') score = 70;
+
+                            return {
+                                idx,
+                                type,
+                                name: name,
+                                value: (htmlEl as any).value || '',
+                                frameIdx: 0, // Placeholder
+                                selector: `[agent-idx="${idx}"]`,
+                                score: score
+                            };
+                        }).filter(Boolean);
+                }, { startIdx: globalIdx });
+
+                results.forEach((c: any) => {
+                    c.frameIdx = fIdx;
+                    allComponents.push(c);
+                });
+                globalIdx += results.length;
+            } catch { }
+        }
+        console.log(`>>ARCALITY_STATUS>> 🔍 Percepción profunda encontró ${allComponents.length} componentes`);
+
+        const sortedComponents = allComponents.sort((a, b) => b.score - a.score).slice(0, 500);
+        const title = await this.page.title();
+        const url = this.page.url();
+
+        // FLUJO DE INGESTA (KnowledgeService Hook)
+        try {
+            const domHash = this.knowledgeService.calculateDomHash(sortedComponents);
+            const viewport = this.page.viewportSize() || { width: 1280, height: 720 };
+            const projectId = this.knowledgeService.getProjectId() || process.env.ARCALITY_PROJECT_ID || '';
+
+            if (projectId) {
+                const requestPayload: PortalIngestRequest = {
+                    project_id: projectId,
+                    target_url: url,
+                    page_title: title,
+                    dom_hash: domHash,
+                    viewport: { width: viewport.width, height: viewport.height },
+                    components: sortedComponents.map(c => {
+                        let compType: 'ACTION' | 'FIELD' | 'INFO' | 'NAVIGATION' | 'DATA' = 'INFO';
+                        if (c.type === 'ACTION') compType = 'ACTION';
+                        else if (c.type === 'FIELD' || c.type === 'OPTION' || c.type === 'DROPDOWN') compType = 'FIELD';
+                        else if (c.name?.toLowerCase().includes('nav') || c.type === 'ACTION') compType = 'NAVIGATION';
+                        return {
+                            tag: c.selector?.split(']')[0]?.replace('[', '') || 'div',
+                            component_type: compType,
+                            semantic_label: c.name,
+                            text_content: c.value,
+                            is_interactive: compType === 'ACTION' || compType === 'FIELD',
+                            attributes: { idx: c.idx, originalType: c.type },
+                            bounding_rect: (c as any).rect || { x: 0, y: 0, width: 0, height: 0 }
+                        };
+                    })
+                };
+                await this.knowledgeService.ingest(requestPayload);
+
+                // HOOK: Catalogar campos de formulario en Memoria Colectiva (fire-and-forget, sin bloqueo)
+                try {
+                    const currentPath = new URL(url).pathname;
+
+                    const fieldComponents = sortedComponents.filter(
+                        c => c.type === 'FIELD' || c.type === 'OPTION' || c.type === 'DROPDOWN'
+                    );
+
+                    // Solo obtener contexto si hay campos nuevos que enviar (para no hacer fetch inútil)
+                    const newFields = fieldComponents.filter(fc => {
+                        const identifier = (fc.name || fc.value || '').trim();
+                        return identifier.length >= 2 && !_sessionFieldCache.has(identifier);
+                    }).slice(0, 5); // Máximo 5 campos nuevos por percepción
+
+                    if (newFields.length > 0) {
+                        // Obtener existentes del servidor (una sola llamada por percepción)
+                        const existingFieldIds = await getKnownFieldIdentifiers(currentPath);
+
+                        for (const fc of newFields) {
+                            const identifier = (fc.name || fc.value || '').trim();
+
+                            // Marcar como enviado en esta sesión (aunque falle, evitamos re-intentos infinitos)
+                            _sessionFieldCache.add(identifier);
+
+                            const selectorLower = (fc.selector || '').toLowerCase();
+                            const nameLower = identifier.toLowerCase();
+                            let fieldType: string = 'text';
+                            if (nameLower.includes('email') || selectorLower.includes('email')) fieldType = 'email';
+                            else if (nameLower.includes('password') || selectorLower.includes('password')) fieldType = 'password';
+                            else if (fc.type === 'DROPDOWN' || selectorLower.includes('select')) fieldType = 'select';
+                            else if (selectorLower.includes('textarea')) fieldType = 'textarea';
+                            else if (selectorLower.includes('checkbox')) fieldType = 'checkbox';
+                            else if (selectorLower.includes('date')) fieldType = 'date';
+                            else if (selectorLower.includes('number')) fieldType = 'number';
+
+                            // FIRE-AND-FORGET: NO await, nunca bloquea la percepción
+                            pushField({
+                                field_identifier: identifier.substring(0, 100),
+                                field_type: fieldType,
+                                is_required: false,
+                                existingFieldIds
+                            }).catch(() => { /* silencioso */ });
+                        }
+                    }
+                } catch { /* Silencioso — no interrumpir el runner */ }
+            }
+        } catch (e: any) {
+            console.log(`>>ARCALITY_STATUS>> ⚠️ Error en hook de ingesta: ${e.message}`);
+        }
+
+        return {
+            url,
+            title,
+            components: sortedComponents
+        };
+    }
+
+    /**
+     * Busca una acción sugerida en la memoria SIN usar tokens.
+     * Compara URL, componentes visuales Y palabras clave del prompt.
+     */
+    async getActionFromGuia(prompt: string, historyLength: number): Promise<AgentAction | null> {
+        try {
+            const fs = require('fs');
+            const path = require('path');
+            const memoryFile = path.join(this.contextDir, 'memoria-agente.json');
+
+            if (!fs.existsSync(memoryFile)) return null;
+
+            const memories = JSON.parse(fs.readFileSync(memoryFile, 'utf8'));
+            const state = await this.getPageState();
+
+            // Estrategia: Solo usar pasos de misiones COMPLETAMENTE EXITOSAS y en la MISMA URL
+            const currentUrl = this.page.url();
+
+            // NUEVA VALIDACIÓN: Extraer palabras clave críticas del prompt
+            const extractCriticalKeywords = (text: string): Set<string> => {
+                const lower = text.toLowerCase();
+                const keywords = new Set<string>();
+
+                // Palabras de posición (CRÍTICAS)
+                if (lower.includes('primera')) keywords.add('primera');
+                if (lower.includes('segunda')) keywords.add('segunda');
+                if (lower.includes('tercera')) keywords.add('tercera');
+                if (lower.includes('cuarta')) keywords.add('cuarta');
+                if (lower.includes('última')) keywords.add('última');
+
+                // Números ordinales en inglés (si el agente piensa en inglés)
+                if (lower.includes('first')) keywords.add('primera');
+                if (lower.includes('second')) keywords.add('segunda');
+                if (lower.includes('third')) keywords.add('tercera');
+                if (lower.includes('fourth')) keywords.add('cuarta');
+                if (lower.includes('last')) keywords.add('última');
+
+                return keywords;
+            };
+
+            // Estrategia SEMÁNTICA: 
+            // 1. Buscamos misiones exitosas previas que compartan la intención (verbos y sustantivos clave)
+            const currentKeywords = extractCriticalKeywords(prompt);
+            const currentVerbs = ['elimina', 'borra', 'quita', 'delete', 'remove', 'crea', 'nueva', 'añade', 'add', 'create', 'new', 'edita', 'modifica', 'cambia', 'edit', 'update'].filter(v => prompt.toLowerCase().includes(v));
+
+            const matchingRun = memories
+                .filter((m: any) => m.success && m.steps_data && m.steps_data[historyLength])
+                .reverse()
+                .find((m: any) => {
+                    const memPrompt = (m.prompt || '').toLowerCase();
+                    const currentPrompt = prompt.toLowerCase();
+
+                    // VALIDACIÓN DE SIMILITUD DE PROMPT (70%+)
+                    // Aumentamos el umbral para evitar que misiones de "verificación" se confundan con "creación"
+                    const words = currentPrompt.split(' ').filter(w => w.length > 3);
+                    if (words.length === 0) return false;
+                    const matches = words.filter(w => memPrompt.includes(w)).length;
+                    if (matches / words.length < 0.7) return false;
+
+                    // VALIDACIÓN DE INTENCIÓN (Verbos)
+                    // Si el prompt actual tiene verbos de "eliminar" y la memoria es de "crear", NO COINCIDEN.
+                    const memVerbs = ['elimina', 'borra', 'quita', 'delete', 'remove', 'crea', 'nueva', 'añade', 'add', 'create', 'new', 'edita', 'modifica', 'cambia', 'edit', 'update'].filter(v => memPrompt.includes(v));
+
+                    const hasSharedVerb = currentVerbs.some(cv => memVerbs.includes(cv));
+                    const hasOppositeIntent = (currentVerbs.some(v => ['elimina', 'borra', 'delete'].includes(v)) && memVerbs.some(v => ['crea', 'nueva', 'create', 'new'].includes(v))) ||
+                        (currentVerbs.some(v => ['crea', 'nueva', 'create', 'new'].includes(v)) && memVerbs.some(v => ['elimina', 'borra', 'delete'].includes(v)));
+
+                    if (hasOppositeIntent) return false;
+                    if (!hasSharedVerb && currentVerbs.length > 0) return false;
+
+                    // Si la misión actual NO tiene verbos pero la de memoria SÍ, probablemente son misiones distintas
+                    if (currentVerbs.length === 0 && memVerbs.length > 0) return false;
+
+                    // VALIDACIÓN DE POSICIÓN/ORDEN
+                    const memKeywords = extractCriticalKeywords(m.prompt || '');
+                    for (const kw of currentKeywords) {
+                        if (!memKeywords.has(kw)) return false;
+                    }
+
+                    const memStep = m.steps_data[historyLength];
+                    if (!memStep) return false;
+
+                    const memUrl = (memStep.url || '').split('?')[0];
+                    const currUrl = currentUrl.split('?')[0];
+
+                    // URL Validation
+                    if (memUrl !== currUrl) return false;
+
+                    // FUZZY MATCHING: Find if any current component matches the remembered one
+                    const foundComponent = state.components.find(c => {
+                        const cleanMemName = (memStep.componentName || '').replace(/\[.*?\]/g, '').replace(/\(.*?\)/g, '').trim().toLowerCase();
+                        const cleanCurrName = (c.name || '').replace(/\[.*?\]/g, '').replace(/\(.*?\)/g, '').trim().toLowerCase();
+                        return (c.selector === memStep.selector) ||
+                            (cleanMemName !== '' && (cleanMemName === cleanCurrName || cleanCurrName.includes(cleanMemName)));
+                    });
+
+                    return !!foundComponent;
+                });
+
+            if (matchingRun) {
+                const memStep = matchingRun.steps_data[historyLength];
+
+                // GUARD: Reject guide steps with unreliable component names
+                const memCompName = memStep.componentName || '';
+                if (memCompName.length > 80) {
+                    console.log(`>>ARCALITY_STATUS>> ⚠️ Guía rechazada: Nombre de componente demasiado largo (${memCompName.length} chars). Delegando a IA.`);
+                    return null;
+                }
+                if (memCompName.includes('[INFERRED]')) {
+                    console.log(`>>ARCALITY_STATUS>> ⚠️ Guía rechazada: Componente con nombre inferido "${memCompName}". Delegando a IA.`);
+                    return null;
+                }
+                if (!memCompName || memCompName.length < 3) {
+                    console.log(`>>ARCALITY_STATUS>> ⚠️ Guía rechazada: Componente sin nombre claro. Delegando a IA.`);
+                    return null;
+                }
+
+                const foundComponent = state.components.find(c => {
+                    const cleanMemName = (memStep.componentName || '').replace(/\[.*?\]/g, '').replace(/\(.*?\)/g, '').trim().toLowerCase();
+                    const cleanCurrName = (c.name || '').replace(/\[.*?\]/g, '').replace(/\(.*?\)/g, '').trim().toLowerCase();
+                    return (c.selector === memStep.selector) ||
+                        (cleanMemName !== '' && (cleanMemName === cleanCurrName || cleanCurrName.includes(cleanMemName)));
+                });
+
+                if (foundComponent) {
+                    return {
+                        thought: `[GUÍA DE ÉXITO] Reutilizando paso maestro aprendido: ${memStep.action_data.action} en ${foundComponent.name}`,
+                        actions: [{
+                            ...memStep.action_data,
+                            idx: foundComponent.idx,
+                            description: foundComponent.name,
+                            selector: foundComponent.selector,
+                            frameIdx: foundComponent.frameIdx,
+                            type: foundComponent.type
+                        }],
+                        finish: memStep.finish || false
+                    };
+                }
+            }
+        } catch (e) { }
+        return null;
+    }
+
+    async askIA(prompt: string, history: string[] = []): Promise<AgentAction> {
+        // MODO BRIDGE: Si existe una URL de portal, delegamos la decisión al servidor (SaaS)
+        if (process.env.ARCALITY_PORTAL_URL) {
+            return this.askBridge(prompt, history);
+        }
+
+        if (!process.env.ANTHROPIC_API_KEY) throw new Error("ANTHROPIC_API_KEY missing");
+
+        const state = await this.getPageState();
+        const screenshot = await this.page.screenshot({ type: 'png' });
+        const base64Img = screenshot.toString('base64');
+
+        const componentsList = state.components.map(c =>
+            `IDX:${c.idx} | TYPE:${c.type} | NAME: "${c.name}"${c.value ? ` | VAL:"${c.value}"` : ''} `
+        ).join('\n');
+
+        // Tool mapping for Anthropic Claude
+        const rawTools = [
+            {
+                name: "perform_ui_actions",
+                description: "Execute standard UI interactions (click, fill, wait) to progress in the mission.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        thought: { type: "string", description: "Reasoning about why these actions are taken." },
+                        actions: {
+                            type: "array",
+                            items: {
+                                type: "object",
+                                properties: {
+                                    idx: { type: "number", description: "The IDX from the components list." },
+                                    action: { enum: ["click", "double_click", "fill", "select", "wait"] },
+                                    value: { type: "string", description: "Text to fill if action is 'fill'." }
+                                },
+                                required: ["action"]
+                            }
+                        },
+                        finish: { type: "boolean", description: "CRITICAL: Set to true only when the mission objective is fully achieved. If true, actions should ideally be empty." }
+                    },
+                    required: ["thought", "actions"]
+                }
+            },
+            {
+                name: "inspect_element_details",
+                description: "QA Skill: Get deep technical metadata of an element (attributes, computed styles). Use this if an element is hidden, disabled, or not responding correctly.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        idx: { type: "number", description: "The IDX of the component to research." }
+                    },
+                    required: ["idx"]
+                }
+            },
+            {
+                name: "report_application_bug",
+                description: "QA Skill: Use this when the mission objective cannot be achieved. This includes: (1) Technical BUGS (elements not appearing), (2) BUSINESS ERRORS (validation messages like 'Conflict', 'Already exists', 'Permission denied'), or (3) Any condition that violates the user's success criteria.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        bug_description: { type: "string", description: "Detailed description of the failure or error message." },
+                        expected_behavior: { type: "string", description: "What the mission expected (Success Criteria)." },
+                        actual_behavior: { type: "string", description: "What actually happened (Failure Criteria)." }
+                    },
+                    required: ["bug_description", "expected_behavior", "actual_behavior"]
+                }
+            },
+            {
+                name: "report_inability_to_proceed",
+                description: "CRITICAL: Use this when you are STUCK, CONFUSED, or CANNOT find required elements after 3+ attempts. This tool allows you to gracefully admit confusion and help the user rephrase the prompt. Use when: (1) You've clicked the same element 3+ times, (2) Cannot find a specific UI element mentioned in the prompt, (3) The prompt is ambiguous or contradictory.",
+                parameters: {
+                    type: "object",
+                    properties: {
+                        confusion_reason: {
+                            type: "string",
+                            description: "Explain why you cannot proceed (e.g., 'Cannot find Menu icon after 5 attempts', 'Stuck clicking same element repeatedly', 'Prompt asks for first but I only see second')"
+                        },
+                        attempts_summary: {
+                            type: "string",
+                            description: "Summarize what you tried (e.g., 'Clicked TAE-063 5 times, went back to list 5 times')"
+                        },
+                        prompt_suggestion: {
+                            type: "string",
+                            description: "Suggest how the user can rephrase for clarity (e.g., 'Please specify the exact text or position of the menu icon')"
+                        }
+                    },
+                    required: ["confusion_reason", "attempts_summary", "prompt_suggestion"]
+                }
+            },
+            ...qaAdvancedTools.map(t => ({
+                name: t.name,
+                description: t.description,
+                parameters: (t as any).input_schema || (t as any).parameters
+            }))
+        ];
+
+        const credentialsContext = (process.env.LOGIN_USER && process.env.LOGIN_PASSWORD)
+            ? `\n🔑 QA CREDENTIALS (Use if login is needed):
+- User: ${process.env.LOGIN_USER}
+- Password: ${process.env.LOGIN_PASSWORD} \n`
+            : '';
+
+        const memoryContext = this.loadMemory(prompt);
+        const skillsContext = this.loadSkills();
+
+        let projectInfo = '';
+        try {
+            const { getProjectContext } = require('../src/projectInspector');
+            const ctx = getProjectContext(process.cwd());
+            projectInfo = `\n🏗️ PROJECT CONTEXT:
+- Name: ${ctx.name}
+- Tech Stack: ${ctx.framework}
+- Environment: ${process.env.NODE_ENV || 'development'}
+- Active Config: ${process.env.ACTIVE_CONFIG || 'Default'}\n`;
+        } catch { }
+
+        // FLUJO DE CONTEXTO (KnowledgeService Hook)
+        let memoryBackendContext = '';
+        try {
+            const contextData = await this.knowledgeService.getContext(state.url);
+
+            if (contextData && (contextData.rules?.length > 0 || contextData.fields?.length > 0)) {
+                memoryBackendContext = `\n🧠 BACKEND COLLECTIVE MEMORY FOR THIS PAGE:\n`;
+                if (contextData.rules?.length > 0) {
+                    memoryBackendContext += `BUSINESS RULES:\n`;
+                    contextData.rules.forEach(r => memoryBackendContext += `- [${r.severity}] ${r.title}: ${r.description}\n`);
+                }
+                if (contextData.fields?.length > 0) {
+                    memoryBackendContext += `KNOWN FIELDS:\n`;
+                    contextData.fields.forEach(f => memoryBackendContext += `- ${f.field_identifier} (${f.field_type}) - Required: ${f.is_required}\n`);
+                }
+                console.log(`>>ARCALITY_STATUS>> 🧠 Contexto de Memoria Colectiva inyectado (${contextData.rules?.length || 0} reglas, ${contextData.fields?.length || 0} campos).`);
+            }
+        } catch (e: any) {
+            console.log(`>>ARCALITY_STATUS>> ⚠️ Error en hook de contexto: ${e.message}`);
+        }
+
+        const systemPromptBlocks = [
+            {
+                type: "text",
+                text: `# IDENTITY
+You are **Arcality**, an elite Senior QA Web Testing Agent. You have 10+ years of experience in manual and automated testing. You are meticulous, thorough, and NEVER take shortcuts. You treat every mission as a real client engagement where your professional reputation is on the line. You MUST use your full arsenal of QA tools — guessing and blind retries are UNACCEPTABLE.
+
+# MISSION
+${prompt}
+
+${projectInfo}
+${skillsContext}
+${memoryContext}
+${credentialsContext}
+${memoryBackendContext}`
+            },
+            {
+                type: "text",
+                text: `\n# METHODOLOGY (MANDATORY — Follow in order)
+Every turn, you MUST follow these 4 phases:
+
+## Phase 1: OBSERVE
+- Read ALL components in CURRENT COMPONENTS carefully.
+- Check the URL — are you on the right page?
+- Read HISTORY — what have you already done? Don't repeat actions.
+- Look for MESSAGE components — errors ([ERROR_CRÍTICO]) or success messages.
+- If you see [INFERRED] in any component name → that name is UNRELIABLE. You MUST call \`inspect_element_details\` on it BEFORE interacting.
+
+## Phase 2: PLAN
+- Based on your observations, decide: What is the ONE next meaningful step toward completing the mission?
+- If filling a form: identify ALL required fields first, then plan to fill multiple fields per turn (3-5 fills at once when possible).
+- Generate UNIQUE data for fields (include timestamps, random suffixes) to avoid "duplicado" errors.
+- If unsure about an element: use \`inspect_element_details\` FIRST. DO NOT guess.
+
+## Phase 3: ACT
+- Execute your planned actions using \`perform_ui_actions\`.
+- Group multiple related actions in one call (e.g., click+fill for 3 fields = 6 actions in one call).
+- For dropdowns/selects: Click to open → WAIT for next turn to see options → Select.
+- For menus: Click menu icon → WAIT for next turn → Click option.
+
+## Phase 4: VERIFY
+- After critical actions (SAVE/CREATE/DELETE), verify the result:
+  - Did a success toast appear?
+  - Did the URL change to a list view?
+  - Are there any new error messages?
+- Use \`validate_element_state\` BEFORE clicking SAVE to ensure the button is enabled.
+- Use \`extract_table_data\` AFTER a save to confirm the record exists in the list.
+
+# MANDATORY TOOL USAGE (NON-NEGOTIABLE)
+These are NOT optional. You MUST use these tools in these situations:
+
+| Situation | Tool | When |
+|-----------|------|------|
+| Action FAILED (Timeout/Error) | \`inspect_element_details\` | IMMEDIATELY, before any retry |
+| Element name has [INFERRED] | \`inspect_element_details\` | BEFORE interacting with it |
+| Before clicking SAVE/GUARDAR | \`validate_element_state\` | To confirm button is enabled |
+| After successful SAVE | \`extract_table_data\` | To verify record was created |
+| UI is frozen/unresponsive | \`capture_console_errors\` | To check for JS errors |
+| Bug found in application | \`create_test_evidence\` | To document with annotated screenshot |
+| Mission complete | \`create_test_evidence\` | To document the final successful state |
+| Modal/popup blocking page | \`send_keyboard_event\` (Escape) | To close the overlay |
+| Time/Date/Color picker field | \`interact_native_control\` | INSTEAD of fill — native inputs need special handling |
+| Element not found on screen | \`scroll_page\` | To reveal off-screen content |
+| Need to close dropdown/menu | \`send_keyboard_event\` (Escape) | After inspecting options |
+| Navigate between form sections | \`send_keyboard_event\` (Tab) | To move focus between fields |
+
+# CRITICAL RULES
+1. **NEVER BLIND-RETRY**: If an action fails, you MUST investigate with \`inspect_element_details\` before retrying. Repeating the exact same failed action is FORBIDDEN.
+2. **NO REPEAT ACTIONS**: Check HISTORY. If you already filled a field or clicked a button, do NOT do it again unless the UI clearly reset OR the button belongs to a different step/modal/section mentioned in the mission (e.g., Save in modal vs Save in main form).
+
+3. **CURRENT STATE > MEMORY**: What you see in CURRENT COMPONENTS is the truth. SUCCESS MEMORY is a guide, not gospel.
+4. **PAGE TRANSITIONS**: If URL contains '/edit' or you see a 'Save' button, you ARE in the edit view. Don't go back.
+5. **MENUS & DROPDOWNS**: After clicking a toggle/menu, WAIT for the next turn. Never click the same menu icon twice in a row.
+6. **ERROR HANDLING**: If you see '🛑 [ERROR_CRÍTICO]', STOP everything. Analyze the error, fix the data, then retry.
+7. **DATA UNIQUENESS**: When generating test data, ALWAYS include a unique suffix (timestamp, counter). Never use "Test123" or "Prueba" alone.
+8. **FINISH CORRECTLY**: Use \`finish: true\` ONLY when the mission objective is FULLY achieved. 
+   - **BEWARE**: If you see a record in a table, confirm it is the one you JUST created (e.g., check timestamp or log message). Do NOT assume an existing record is your success.
+   - **MESSAGES**: Be suspicious of success messages that appear right after login or page load. Real success messages usually appear IMMEDIATELY after you click SAVE.
+9. **LARGE COMPONENTS**: If a component name is >50 characters, it's probably a CONTAINER, not a field. Do not interact with it.
+10. **STUCK DETECTION**: If history shows 3+ similar actions without progress, use \`report_inability_to_proceed\`.
+11. **NEGATIVE TESTING**: If mission expects an error (e.g., "verifica que no se pueda guardar sin campos"), and you see that error, the mission is SUCCESS. Use \`finish: true\`.
+12. **GUIDE CONFLICT**: If SUCCESS MEMORY disagrees with what you see on screen, ABANDON the memory and trust your eyes.
+13. **NATIVE CONTROLS**: For \`<input type="time">\`, \`<input type="date">\`, or similar native pickers, NEVER use \`fill\` repeatedly. Use \`interact_native_control\` or \`send_keyboard_event\` instead. If \`fill\` fails once, switch strategy immediately.`,
+                cache_control: { type: "ephemeral" }
+            }
+        ];
+
+
+        // Adjuntar al reporte de Playwright (Evidencia Visual)
+        if (this.testInfo) {
+            await this.testInfo.attach(`turn-${history.length}-vision`, {
+                body: screenshot,
+                contentType: 'image/png'
+            });
+        }
+
+        const anthropicMessages: any[] = [
+            {
+                role: "user",
+                content: [
+                    {
+                        type: "image",
+                        source: {
+                            type: "base64",
+                            media_type: "image/png",
+                            data: base64Img
+                        },
+                        cache_control: { type: "ephemeral" }
+                    },
+                    {
+                        type: "text",
+                        text: `MISSION STATUS:
+- URL: ${state.url}
+- Title: ${state.title}
+
+PROGRESS TRACKING:
+- IMPORTANT: This mission is a SEQUENCE of steps. Analyze the HISTORY to see which steps are DONE.
+- SEARCH FOR MESSAGES: If you see a component with type 'MESSAGE' (especially [ERROR] or [SUCCESS]) that matches the mission objective, the MISSION IS COMPLETE.
+- If mission is complete, use 'perform_ui_actions' with 'finish: true' immediately.
+- DO NOT restart or go back to previous steps if you are already in the target view.
+
+CURRENT COMPONENTS:
+${componentsList}
+
+CONSOLE LOGS:
+${this.logs.join('\n') || 'None'}
+
+HISTORY (last 25 steps):
+${history.slice(-25).join('\n') || 'None'}`
+                    },
+                    {
+                        type: "text",
+                        text: `Please analyze the current state and provide the next step.`,
+                        cache_control: { type: "ephemeral" }
+                    }
+                ]
+            }
+        ];
+
+        console.log(`>>ARCALITY_STATUS>> 🧠 Arcality está procesando la visión...`);
+        const startTime = Date.now();
+
+        for (let turn = 0; turn < 10; turn++) {
+            let response: Response;
+            let retryCount = 0;
+            const maxRetries = 3;
+
+            while (true) {
+                const isProxyMode = !!process.env.ARCALITY_API_URL;
+                const endpointUrl = isProxyMode
+                    ? `${process.env.ARCALITY_API_URL}/api/v1/ai/proxy`
+                    : "https://api.anthropic.com/v1/messages";
+
+                const headers: Record<string, string> = {
+                    "Content-Type": "application/json"
+                };
+
+                if (isProxyMode) {
+                    headers["x-api-key"] = process.env.ARCALITY_API_KEY || "";
+                } else {
+                    headers["x-api-key"] = process.env.ANTHROPIC_API_KEY!;
+                    headers["anthropic-version"] = "2023-06-01";
+                }
+
+                response = await fetch(endpointUrl, {
+                    method: "POST",
+                    headers,
+                    body: JSON.stringify({
+                        model: process.env.CLAUDE_MODEL || "claude-3-5-sonnet-20241022",
+                        max_tokens: 4096,
+                        system: systemPromptBlocks,
+                        tools: rawTools.map(t => ({
+                            name: t.name,
+                            description: t.description,
+                            input_schema: (t as any).parameters || (t as any).input_schema
+                        })),
+                        messages: anthropicMessages,
+                        temperature: 0.2
+                    })
+                });
+
+                if (response.ok) break;
+
+                const errorText = await response.text();
+                const isTransient = response.status === 529 || response.status === 429 || response.status === 503;
+
+                if (isTransient && retryCount < maxRetries) {
+                    retryCount++;
+                    const delay = Math.pow(2, retryCount) * 1000;
+                    console.log(`\n>>ARCALITY_STATUS>> ⚠️ Arcality está saturado (${response.status}). Reintentando...`);
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                    continue;
+                }
+
+                throw new Error(`Arcality Brain Error: ${errorText}`);
+            }
+
+            const data: any = await response.json();
+            const message = data;
+
+            anthropicMessages.push({
+                role: "assistant",
+                content: message.content
+            });
+
+            const toolCalls = message.content.filter((c: any) => c.type === 'tool_use');
+            const textResponse = message.content.find((c: any) => c.type === 'text')?.text || "";
+
+            if (toolCalls.length === 0) {
+                console.log(`(${((Date.now() - startTime) / 1000).toFixed(1)}s)`);
+                return { thought: textResponse || "No action decided", actions: [] };
+            }
+
+            const toolResults: any[] = [];
+            let uiActionCall = null;
+
+            for (const toolUse of toolCalls) {
+                const toolName = toolUse.name;
+                const toolInput = toolUse.input;
+
+                if (toolName === "perform_ui_actions") {
+                    uiActionCall = { id: toolUse.id, input: toolInput };
+                    if (toolCalls.length > 1) {
+                        toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: "UI Action buffered." });
+                    }
+                } else if (toolName === "inspect_element_details") {
+                    const idx = toolInput.idx;
+                    const c = state.components.find(comp => comp.idx === idx);
+                    console.log(`>>ARCALITY_STATUS>> 🔍 Investigando IDX:${idx}...`);
+
+                    let details = "Element not found or no longer present.";
+                    if (c) {
+                        try {
+                            details = await this.page.frames()[c.frameIdx].evaluate((s) => {
+                                const el = document.querySelector(s) as HTMLElement;
+                                if (!el) return "Not found";
+                                const styles = window.getComputedStyle(el);
+                                return JSON.stringify({
+                                    tag: el.tagName,
+                                    id: el.id,
+                                    classes: el.className,
+                                    isVisible: el.offsetParent !== null,
+                                    rect: el.getBoundingClientRect(),
+                                    attributes: Array.from(el.attributes).map(a => `${a.name}="${a.value}"`),
+                                    style: { display: styles.display, pointerEvents: styles.pointerEvents, opacity: styles.opacity }
+                                }, null, 2);
+                            }, c.selector);
+                        } catch (e: any) { details = `Error inspecting: ${e.message}`; }
+                    }
+                    toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: details });
+                } else if (toolName === "report_application_bug") {
+                    console.error(`🐛 [BUG DETECTED] ${toolInput.bug_description}`);
+
+                    // REGLA DE APRENDIZAJE: Registrar bug como regla de negocio para el futuro
+                    try {
+                        const url = this.page.url();
+                        await this.knowledgeService.saveRule(
+                            "Validación Detectada (Auto-Learning)",
+                            `Error: ${toolInput.bug_description}. Se esperaba: ${toolInput.expected_behavior}`,
+                            'WARNING',
+                            url
+                        );
+                    } catch (e) { }
+
+                    throw new Error(`APPLICATION BUG: ${toolInput.bug_description}`);
+                } else if (toolName === "report_inability_to_proceed") {
+                    toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: "Confusion acknowledged." });
+                    return {
+                        thought: `DISCULPA: ${toolInput.confusion_reason}\n\n💡 SUGERENCIA: ${toolInput.prompt_suggestion}`,
+                        actions: [],
+                        finish: true
+                    };
+                } else if (toolName === "validate_element_state") {
+                    const { idx, validations } = toolInput;
+                    const c = state.components.find(comp => comp.idx === idx);
+                    let result = "";
+                    if (!c) {
+                        result = "Element not found.";
+                    } else {
+                        try {
+                            result = await this.page.frames()[c.frameIdx].evaluate(({ selector, validations }) => {
+                                const el = document.querySelector(selector) as HTMLElement;
+                                if (!el) return "Element no longer exists in DOM.";
+
+                                const styles = window.getComputedStyle(el);
+                                const results = validations.map((v: any) => {
+                                    let pass = false;
+                                    let actual = "";
+                                    switch (v.type) {
+                                        case 'exists':
+                                            pass = !!el;
+                                            actual = pass ? "exists" : "none";
+                                            break;
+                                        case 'visible':
+                                            pass = el.offsetParent !== null && styles.visibility !== 'hidden' && styles.display !== 'none' && parseFloat(styles.opacity) > 0;
+                                            actual = pass ? "visible" : "hidden";
+                                            break;
+                                        case 'enabled':
+                                            pass = !(el as any).disabled && el.getAttribute('aria-disabled') !== 'true';
+                                            actual = pass ? "enabled" : "disabled";
+                                            break;
+                                        case 'disabled':
+                                            pass = (el as any).disabled || el.getAttribute('aria-disabled') === 'true';
+                                            actual = pass ? "disabled" : "enabled";
+                                            break;
+                                        case 'contains_text':
+                                            actual = el.innerText || "";
+                                            pass = actual.toLowerCase().includes(v.expected_value.toLowerCase());
+                                            break;
+                                        case 'has_value':
+                                            actual = (el as HTMLInputElement).value || "";
+                                            pass = actual === v.expected_value;
+                                            break;
+                                        case 'is_empty':
+                                            actual = (el as HTMLInputElement).value || el.innerText || "";
+                                            pass = actual.trim() === "";
+                                            break;
+                                        case 'has_class':
+                                            actual = el.className;
+                                            pass = el.classList.contains(v.expected_value);
+                                            break;
+                                    }
+                                    return `${v.type}: ${pass ? 'PASS' : 'FAIL'} (Actual: "${actual}")`;
+                                });
+                                return results.join('\n');
+                            }, { selector: c.selector, validations });
+                        } catch (e: any) { result = `Error validating: ${e.message}`; }
+                    }
+                    toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: result });
+                } else if (toolName === "extract_table_data") {
+                    const { table_identifier, max_rows = 50 } = toolInput;
+                    console.log(`>>ARCALITY_STATUS>> 📊 Extrayendo tabla: ${table_identifier}...`);
+                    try {
+                        const tableData = await this.page.evaluate(({ identifier, limit }) => {
+                            const findTable = () => {
+                                const headers = Array.from(document.querySelectorAll('h1, h2, h3, h4, th, label, span, p, div'))
+                                    .filter(el => el.textContent?.includes(identifier));
+
+                                for (const h of headers) {
+                                    let curr: HTMLElement | null = h as HTMLElement;
+                                    for (let i = 0; i < 5; i++) {
+                                        if (!curr) break;
+                                        const table = curr.querySelector('table') || (curr.tagName === 'TABLE' ? curr : null);
+                                        if (table) return table;
+                                        curr = curr.parentElement;
+                                    }
+                                }
+                                return document.querySelector('table');
+                            };
+
+                            const table = findTable();
+                            if (!table) return "No table found with identifier: " + identifier;
+
+                            const rows = Array.from(table.querySelectorAll('tr')).slice(0, limit);
+                            return rows.map(r => {
+                                return Array.from(r.querySelectorAll('td, th')).map(c => c.textContent?.trim() || "");
+                            });
+                        }, { identifier: table_identifier, limit: max_rows });
+                        toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: JSON.stringify(tableData, null, 2) });
+                    } catch (e: any) { toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error extracting: ${e.message}` }); }
+                } else if (toolName === "capture_console_errors") {
+                    const logs = this.logs.length > 0 ? this.logs.join('\n') : "No console errors/warnings/network errors captured.";
+                    toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: logs });
+                } else if (toolName === "assert_url_pattern") {
+                    const { pattern, should_match = true } = toolInput;
+                    const url = this.page.url();
+                    const match = url.includes(pattern);
+                    const pass = should_match ? match : !match;
+                    const result = `URL Assertion: ${pass ? 'PASS' : 'FAIL'} (Current URL: ${url} | Pattern: ${pattern} | Expected match: ${should_match})`;
+                    toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: result });
+
+                } else if (toolName === "measure_page_performance") {
+                    const { thresholds = {} } = toolInput;
+                    console.log(`>>ARCALITY_STATUS>> ⚡ Midiendo rendimiento de página...`);
+                    try {
+                        const perfData = await this.page.evaluate(() => {
+                            const nav = performance.getEntriesByType('navigation')[0] as PerformanceNavigationTiming;
+                            const paint = performance.getEntriesByType('paint');
+                            const resources = performance.getEntriesByType('resource') as PerformanceResourceTiming[];
+                            const fcp = paint.find(p => p.name === 'first-contentful-paint');
+
+                            return {
+                                load_time_ms: nav ? Math.round(nav.loadEventEnd - nav.startTime) : null,
+                                dom_content_loaded_ms: nav ? Math.round(nav.domContentLoadedEventEnd - nav.startTime) : null,
+                                first_contentful_paint_ms: fcp ? Math.round(fcp.startTime) : null,
+                                network_requests: resources.length,
+                                total_resource_size_kb: Math.round(resources.reduce((sum, r) => sum + (r.transferSize || 0), 0) / 1024)
+                            };
+                        });
+
+                        const results: string[] = [
+                            `📊 PERFORMANCE METRICS:`,
+                            `  Load Time: ${perfData.load_time_ms ?? 'N/A'}ms`,
+                            `  DOM Content Loaded: ${perfData.dom_content_loaded_ms ?? 'N/A'}ms`,
+                            `  First Contentful Paint: ${perfData.first_contentful_paint_ms ?? 'N/A'}ms`,
+                            `  Network Requests: ${perfData.network_requests}`,
+                            `  Total Resource Size: ${perfData.total_resource_size_kb}KB`
+                        ];
+                        toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: results.join('\n') });
+                    } catch (e: any) {
+                        toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error measuring performance: ${e.message}` });
+                    }
+
+                } else if (toolName === "save_navigation_checkpoint") {
+                    const { checkpoint_name, include_storage = true } = toolInput;
+                    console.log(`>>ARCALITY_STATUS>> 💾 Guardando punto de control: "${checkpoint_name}"...`);
+                    try {
+                        const url = this.page.url();
+                        const context = this.page.context();
+                        const storageState = await context.storageState();
+
+                        let localStorage: Record<string, string> = {};
+                        let sessionStorage: Record<string, string> = {};
+
+                        if (include_storage) {
+                            const storageData = await this.page.evaluate(() => {
+                                const ls: Record<string, string> = {};
+                                for (let i = 0; i < window.localStorage.length; i++) {
+                                    const key = window.localStorage.key(i);
+                                    if (key) ls[key] = window.localStorage.getItem(key) || '';
+                                }
+                                const ss: Record<string, string> = {};
+                                for (let i = 0; i < window.sessionStorage.length; i++) {
+                                    const key = window.sessionStorage.key(i);
+                                    if (key) ss[key] = window.sessionStorage.getItem(key) || '';
+                                }
+                                return { localStorage: ls, sessionStorage: ss };
+                            });
+                            localStorage = storageData.localStorage;
+                            sessionStorage = storageData.sessionStorage;
+                        }
+
+                        this.checkpoints.set(checkpoint_name, { url, storageState, localStorage, sessionStorage });
+
+                        const result = `✅ Checkpoint "${checkpoint_name}" saved successfully.`;
+                        toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: result });
+                    } catch (e: any) {
+                        toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error saving checkpoint: ${e.message}` });
+                    }
+
+                } else if (toolName === "restore_navigation_checkpoint") {
+                    const { checkpoint_name } = toolInput;
+                    console.log(`>>ARCALITY_STATUS>> 🔄 Restaurando punto de control: "${checkpoint_name}"...`);
+
+                    const checkpoint = this.checkpoints.get(checkpoint_name);
+                    if (!checkpoint) {
+                        toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `❌ Checkpoint "${checkpoint_name}" not found.` });
+                    } else {
+                        try {
+                            const context = this.page.context();
+                            await context.clearCookies();
+                            if (checkpoint.storageState.cookies?.length) {
+                                await context.addCookies(checkpoint.storageState.cookies);
+                            }
+                            await this.page.goto(checkpoint.url, { waitUntil: 'domcontentloaded', timeout: 15000 });
+                            await this.page.evaluate(({ ls, ss }) => {
+                                window.localStorage.clear();
+                                for (const [k, v] of Object.entries(ls)) window.localStorage.setItem(k, v);
+                                window.sessionStorage.clear();
+                                for (const [k, v] of Object.entries(ss)) window.sessionStorage.setItem(k, v);
+                            }, { ls: checkpoint.localStorage, ss: checkpoint.sessionStorage });
+                            await this.page.reload({ waitUntil: 'domcontentloaded', timeout: 15000 });
+                            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `✅ Checkpoint "${checkpoint_name}" restored.` });
+                        } catch (e: any) {
+                            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error restoring checkpoint: ${e.message}` });
+                        }
+                    }
+
+                } else if (toolName === "create_test_evidence") {
+                    const { evidence_type, annotations, save_as, description, finish_run = false } = toolInput;
+                    console.log(`📸 [SKILL] Creating test evidence: "${save_as}"...`);
+                    try {
+                        const filename = save_as.replace(/[^a-zA-Z0-9_-]/g, '_');
+
+                        // 1. Appy visual annotations if requested
+                        if (annotations && annotations.length > 0) {
+                            await this.page.evaluate((anns) => {
+                                anns.forEach((ann: any) => {
+                                    const el = document.querySelector(`[agent-idx="${ann.idx}"]`) as HTMLElement;
+                                    if (el) {
+                                        const rect = el.getBoundingClientRect();
+                                        const div = document.createElement('div');
+                                        div.className = 'arcality-annotation';
+                                        div.style.position = 'absolute';
+                                        div.style.border = `3px solid ${ann.color || 'red'}`;
+                                        div.style.top = `${rect.top + window.scrollY}px`;
+                                        div.style.left = `${rect.left + window.scrollX}px`;
+                                        div.style.width = `${rect.width}px`;
+                                        div.style.height = `${rect.height}px`;
+                                        div.style.pointerEvents = 'none';
+                                        div.style.zIndex = '1000000';
+
+                                        const label = document.createElement('span');
+                                        label.innerText = ann.label;
+                                        label.style.background = ann.color || 'red';
+                                        label.style.color = 'white';
+                                        label.style.fontSize = '12px';
+                                        label.style.padding = '2px 4px';
+                                        label.style.position = 'absolute';
+                                        label.style.top = '-20px';
+                                        label.style.left = '0';
+                                        div.appendChild(label);
+                                        document.body.appendChild(div);
+                                    }
+                                });
+                            }, annotations);
+                        }
+
+                        let buffer: Buffer = await this.page.screenshot({
+                            type: 'png',
+                            fullPage: evidence_type === 'full_page_screenshot'
+                        });
+
+                        // 2. Clean up annotations
+                        await this.page.evaluate(() => {
+                            document.querySelectorAll('.arcality-annotation').forEach(el => el.remove());
+                        });
+
+                        if (this.testInfo) {
+                            // Attach image
+                            await this.testInfo.attach(filename, { body: buffer, contentType: 'image/png' });
+
+                            // Attach description if exists
+                            if (description) {
+                                await this.testInfo.attach(`${filename}_description`, {
+                                    body: Buffer.from(description, 'utf-8'),
+                                    contentType: 'text/plain'
+                                });
+                            }
+
+                            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `✅ Evidence "${filename}" created and attached.` });
+
+                            if (finish_run) {
+                                this.lastScreenshot = base64Img;
+                                return { thought: `Evidence "${description || filename}" created. Mission complete.`, actions: [], finish: true };
+                            }
+                        } else {
+                            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `⚠️ testInfo not available.` });
+                        }
+                    } catch (e: any) {
+                        toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error creating evidence: ${e.message}` });
+                    }
+
+                } else if (toolName === "send_keyboard_event") {
+                    const { key, idx, repeat = 1 } = toolInput;
+                    console.log(`>>ARCALITY_STATUS>> ⌨️ Enviando tecla: "${key}" ${idx !== undefined ? `(focus en IDX:${idx})` : '(focus actual)'} x${repeat}`);
+                    try {
+                        // Focus on element if idx provided
+                        if (idx !== undefined) {
+                            const c = state.components.find(comp => comp.idx === idx);
+                            if (c) {
+                                const loc = this.page.frames()[c.frameIdx].locator(c.selector).first();
+                                await loc.focus({ timeout: 5000 }).catch(async () => {
+                                    await loc.click({ timeout: 5000, force: true });
+                                });
+                            }
+                        }
+
+                        for (let i = 0; i < Math.min(repeat, 20); i++) {
+                            await this.page.keyboard.press(key);
+                            if (repeat > 1) await this.page.waitForTimeout(100);
+                        }
+
+                        toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `✅ Key "${key}" pressed ${repeat} time(s).` });
+                    } catch (e: any) {
+                        toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error sending key: ${e.message}` });
+                    }
+
+                } else if (toolName === "interact_native_control") {
+                    const { idx, control_type, value } = toolInput;
+                    const c = state.components.find(comp => comp.idx === idx);
+                    console.log(`>>ARCALITY_STATUS>> 🎛️ Control nativo: ${control_type} IDX:${idx} → "${value}"`);
+
+                    if (!c) {
+                        toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: "Element not found." });
+                    } else {
+                        try {
+                            const frame = this.page.frames()[c.frameIdx];
+                            const loc = frame.locator(c.selector).first();
+
+                            switch (control_type) {
+                                case 'time':
+                                case 'date':
+                                case 'datetime': {
+                                    // Strategy 1: Direct Playwright fill (works on most browsers)
+                                    try {
+                                        await loc.fill(value, { timeout: 3000 });
+                                        const actualValue = await loc.inputValue();
+                                        if (actualValue && actualValue !== '') {
+                                            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `✅ ${control_type} set to "${actualValue}" via fill().` });
+                                            break;
+                                        }
+                                    } catch { /* fill failed, try keyboard */ }
+
+                                    // Strategy 2: Click + select all + type
+                                    await loc.click({ force: true });
+                                    await this.page.keyboard.press('Control+a');
+                                    await this.page.waitForTimeout(100);
+
+                                    // For time inputs, type digits directly (e.g., "1305" for "13:05")
+                                    const digits = value.replace(/[:-T]/g, '');
+                                    await this.page.keyboard.type(digits, { delay: 50 });
+
+                                    const finalValue = await loc.inputValue().catch(() => '');
+                                    toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `✅ ${control_type} set via keyboard. Current value: "${finalValue}".` });
+                                    break;
+                                }
+                                case 'color':
+                                    await loc.fill(value, { timeout: 3000 });
+                                    toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `✅ Color set to "${value}".` });
+                                    break;
+                                case 'range': {
+                                    const numVal = parseFloat(value);
+                                    await loc.fill(String(numVal), { timeout: 3000 }).catch(async () => {
+                                        // Fallback: set value via JS
+                                        await frame.evaluate(({ sel, val }) => {
+                                            const el = document.querySelector(sel) as HTMLInputElement;
+                                            if (el) {
+                                                el.value = val;
+                                                el.dispatchEvent(new Event('input', { bubbles: true }));
+                                                el.dispatchEvent(new Event('change', { bubbles: true }));
+                                            }
+                                        }, { sel: c.selector, val: String(numVal) });
+                                    });
+                                    toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `✅ Range set to ${numVal}.` });
+                                    break;
+                                }
+                                case 'select': {
+                                    // Try by label first, then by value
+                                    try {
+                                        await loc.selectOption({ label: value }, { timeout: 3000 });
+                                    } catch {
+                                        try {
+                                            await loc.selectOption({ value: value }, { timeout: 3000 });
+                                        } catch {
+                                            await loc.selectOption(value, { timeout: 3000 });
+                                        }
+                                    }
+                                    const selected = await loc.inputValue().catch(() => 'unknown');
+                                    toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `✅ Option selected. Value: "${selected}".` });
+                                    break;
+                                }
+                                case 'contenteditable':
+                                    await loc.click({ force: true });
+                                    await this.page.keyboard.press('Control+a');
+                                    await this.page.keyboard.type(value, { delay: 30 });
+                                    toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `✅ Content set to "${value}".` });
+                                    break;
+                                default:
+                                    toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `❌ Unknown control type: ${control_type}` });
+                            }
+                        } catch (e: any) {
+                            toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error interacting with native control: ${e.message}` });
+                        }
+                    }
+
+                } else if (toolName === "scroll_page") {
+                    const { direction, amount = 500, idx } = toolInput;
+                    console.log(`>>ARCALITY_STATUS>> 📜 Scroll: ${direction} ${amount}px ${idx !== undefined ? `(container IDX:${idx})` : '(page)'}`);
+                    try {
+                        if (idx !== undefined) {
+                            const c = state.components.find(comp => comp.idx === idx);
+                            if (c) {
+                                const loc = this.page.frames()[c.frameIdx].locator(c.selector).first();
+                                await loc.evaluate((el, args) => {
+                                    const d = args.direction;
+                                    const a = args.amount;
+                                    if (d === 'top') el.scrollTop = 0;
+                                    else if (d === 'bottom') el.scrollTop = el.scrollHeight;
+                                    else if (d === 'down') el.scrollTop += a;
+                                    else if (d === 'up') el.scrollTop -= a;
+                                    else if (d === 'left') el.scrollLeft -= a;
+                                    else if (d === 'right') el.scrollLeft += a;
+                                }, { direction, amount });
+                            }
+                        } else {
+                            switch (direction) {
+                                case 'down': await this.page.mouse.wheel(0, amount); break;
+                                case 'up': await this.page.mouse.wheel(0, -amount); break;
+                                case 'right': await this.page.mouse.wheel(amount, 0); break;
+                                case 'left': await this.page.mouse.wheel(-amount, 0); break;
+                                case 'top': await this.page.evaluate(() => window.scrollTo(0, 0)); break;
+                                case 'bottom': await this.page.evaluate(() => window.scrollTo(0, document.body.scrollHeight)); break;
+                            }
+                        }
+                        await this.page.waitForTimeout(300);
+                        toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `✅ Scrolled ${direction} ${direction === 'top' || direction === 'bottom' ? 'completely' : `${amount}px`}. Page state will refresh on next turn.` });
+                    } catch (e: any) {
+                        toolResults.push({ type: "tool_result", tool_use_id: toolUse.id, content: `Error scrolling: ${e.message}` });
+                    }
+                }
+            }
+
+            if (toolResults.length > 0) {
+                anthropicMessages.push({
+                    role: "user",
+                    content: toolResults
+                });
+                // Si solo eran herramientas de investigación/QA, continuamos el loop interno de la IA
+                if (!uiActionCall) continue;
+            }
+
+            if (uiActionCall) {
+                const input = uiActionCall.input;
+                console.log(`(${((Date.now() - startTime) / 1000).toFixed(1)}s)`);
+                this.lastScreenshot = base64Img;
+                return {
+                    thought: input.thought,
+                    actions: input.actions.map((a: any) => {
+                        const c = state.components.find(comp => comp.idx === a.idx);
+                        let finalValue = a.value;
+                        // AUTO-FIX for Date inputs: Convert DD/MM/YYYY to YYYY-MM-DD
+                        if (a.action === 'fill' && finalValue && /^\d{2}\/\d{2}\/\d{4}$/.test(finalValue)) {
+                            const [d, m, y] = finalValue.split('/');
+                            finalValue = `${y}-${m}-${d}`;
+                        }
+                        return { ...a, value: finalValue, selector: c?.selector, frameIdx: c?.frameIdx, description: c?.name, type: c?.type };
+                    }),
+                    finish: input.finish
+                };
+            }
+        }
+        return { thought: "Max internal turns reached", actions: [] };
+    }
+
+    /**
+     * QA Skill: Genera una explicación "humana" y amigable de por qué la misión fue exitosa.
+     */
+    async humanizeMissionResult(prompt: string, history: string[]): Promise<string | null> {
+        if (!process.env.ANTHROPIC_API_KEY) return null;
+
+        try {
+            const isProxyMode = !!process.env.ARCALITY_API_URL;
+            const endpointUrl = isProxyMode
+                ? `${process.env.ARCALITY_API_URL}/api/v1/ai/proxy`
+                : "https://api.anthropic.com/v1/messages";
+
+            const headers: Record<string, string> = {
+                "Content-Type": "application/json"
+            };
+
+            if (isProxyMode) {
+                headers["x-api-key"] = process.env.ARCALITY_API_KEY || "";
+            } else {
+                headers["x-api-key"] = process.env.ANTHROPIC_API_KEY!;
+                headers["anthropic-version"] = "2023-06-01";
+            }
+
+            const response = await fetch(endpointUrl, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    model: process.env.CLAUDE_MODEL || "claude-3-5-sonnet-20241022",
+                    max_tokens: 300,
+                    system: "Eres un Senior QA personalizador de reportes. Tu tarea es resumir en una sola frase corta, profesional y amigable por qué una misión de testing fue exitosa basándote en el historial de pasos. Usa un tono de victoria. No menciones detalles técnicos como 'selectores' o 'DOM'. El resumen debe empezar con algo como '¡Misión cumplida! ...'",
+                    messages: [
+                        { role: "user", content: `Misión original: ${prompt}\n\nhistory of steps:\n${history.join('\n')}` }
+                    ]
+                })
+            });
+
+            const data: any = await response.json();
+            return data.content?.[0]?.text || null;
+        } catch (e) {
+            return null;
+        }
+    }
+
+    /**
+     * MODO BRIDGE: Envía la percepción de la CLI hacia el Portal Web (SaaS)
+     * para que el servidor decida la acción usando su propia infraestructura e IP.
+     */
+    private async askBridge(prompt: string, history: string[] = []): Promise<AgentAction> {
+        console.log(`>>ARCALITY_STATUS>> 🌐 Conectando con el cerebro de Arcality (Modo SaaS)...`);
+
+        const state = await this.getPageState();
+        const screenshot = await this.page.screenshot({ type: 'png' });
+
+        // Payload enriquecido para el portal
+        const payload = {
+            mission: prompt,
+            history: history,
+            percept: {
+                url: state.url,
+                title: state.title,
+                components: state.components,
+                screenshot: screenshot.toString('base64'),
+                logs: this.logs
+            },
+            context: {
+                version: "1.0.1",
+                model: process.env.CLAUDE_MODEL || "claude-3-5-sonnet-20241022",
+                config: process.env.ACTIVE_CONFIG || "Default"
+            }
+        };
+
+        try {
+            const baseUrl = process.env.ARCALITY_PORTAL_URL || "";
+            const url = baseUrl.endsWith('/')
+                ? baseUrl + 'api/v1/decide'
+                : baseUrl + '/api/v1/decide';
+
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                    'x-arcality-cli-version': '1.0.1'
+                },
+                body: JSON.stringify(payload)
+            });
+
+            if (!response.ok) {
+                const errorText = await response.text();
+                throw new Error(`SaaS Bridge Error (${response.status}): ${errorText}`);
+            }
+
+            const decision = await response.json() as AgentAction;
+            return decision;
+
+        } catch (err: any) {
+            console.error(chalk.red(`\n❌ Error en el Bridge de Arcality: ${err.message}`));
+            console.log(chalk.yellow(`\n⚠️ Reintentando modo local (Direct Claude)...`));
+
+            // Fallback al modo local si el bridge falla por red o configuración
+            delete process.env.ARCALITY_PORTAL_URL;
+            return this.askIA(prompt, history);
+        }
+    }
+
+    /**
+     * QA Skill: Summarizes the mission execution into a clean, human-friendly English YAML format.
+     */
+    async summarizeMissionToYaml(prompt: string, history: string[], startUrl: string): Promise<string | null> {
+        if (!process.env.ANTHROPIC_API_KEY) return null;
+
+        try {
+            const historyStr = history.slice(-30).join('\n');
+            const isProxyMode = !!process.env.ARCALITY_API_URL;
+            const endpointUrl = isProxyMode
+                ? `${process.env.ARCALITY_API_URL}/api/v1/ai/proxy`
+                : "https://api.anthropic.com/v1/messages";
+
+            const headers: Record<string, string> = {
+                "Content-Type": "application/json"
+            };
+
+            if (isProxyMode) {
+                headers["x-api-key"] = process.env.ARCALITY_API_KEY || "";
+            } else {
+                headers["x-api-key"] = process.env.ANTHROPIC_API_KEY!;
+                headers["anthropic-version"] = "2023-06-01";
+            }
+
+            const response = await fetch(endpointUrl, {
+                method: "POST",
+                headers,
+                body: JSON.stringify({
+                    model: process.env.CLAUDE_MODEL || "claude-3-5-sonnet-20241022",
+                    max_tokens: 1000,
+                    system: `You are an elite QA Engineer. Your task is to transform a raw execution history into a clean, human-friendly English YAML Mission Card.
+                    
+STRICT YAML STRUCTURE:
+Title: "Descriptive title for the test"
+StartAt: "The relative path where the test began"
+Steps: |
+  - Bullet points of human-readable steps performed
+Data:
+  key: "value" # Group any data used (names, emails, prices). Set to null if no specific data was used.
+SuccessCriteria: |
+  - Bullet points of how success was verified
+
+RULES:
+1. Use professional English.
+2. The 'Steps' must be what actually happened in the history, but simplified for a human to read.
+3. 'Data' should extract values mentioned in the history (e.g., if you filled a name with 'Test-123', include it).
+4. Output ONLY the YAML block. No preamble or explanations.`,
+                    messages: [
+                        { role: "user", content: `Original Mission: ${prompt}\nStarting URL: ${startUrl}\n\nExecution history:\n${historyStr}` }
+                    ],
+                    temperature: 0.1
+                })
+            });
+
+            const data: any = await response.json();
+            let yaml = data.content?.[0]?.text || null;
+
+            if (yaml) {
+                // Remove markdown blocks if present
+                yaml = yaml.replace(/```yaml\n?/g, "").replace(/```/g, "").trim();
+            }
+            return yaml;
+        } catch (e) {
+            console.error("Error generating Smart YAML:", e);
+            return null;
+        }
+    }
+}