@arcadialdev/arcality 2.6.6 → 3.0.0

package/bin/arcality.mjs

@@ -15,6 +15,7 @@ let isRun = false;
 let isInit = false;
 let isSetup = false;
 let isLogs = false;
+let isRunAll = false; // CI/CD mode: runs all missions from API headlessly
 
 // Buscamos los comandos en cualquier posición para evitar filtros de NPM en Windows
 rawArgs.forEach(arg => {
@@ -22,6 +23,7 @@ rawArgs.forEach(arg => {
     if (arg === 'init') isInit = true;
     if (arg === 'setup') isSetup = true;
     if (arg === '--logs') isLogs = true;
+    if (arg === '--run-all') isRunAll = true;
 });
 
 if (isLogs) {
@@ -38,6 +40,15 @@ if (isLogs) {
         cwd: process.cwd(),
         env: { ...process.env, ARCALITY_ROOT: PACKAGE_ROOT }
     }).on('exit', code => process.exit(code || 0));
+} else if (isRunAll) {
+    // CI/CD HEADLESS MODE: Descarga y ejecuta todas las misiones del proyecto desde la API
+    // Uso: arcality --run-all [--workers=4] [--tags=smoke,regression] [--project-id=xxx]
+    const mainScript = path.join(PACKAGE_ROOT, 'scripts', 'gen-and-run.mjs');
+    spawn('node', [mainScript, '--run-all', ...rawArgs.filter(a => a !== '--run-all')], {
+        stdio: 'inherit',
+        cwd: process.cwd(),
+        env: { ...process.env, ARCALITY_ROOT: PACKAGE_ROOT, CI: process.env.CI || 'true' }
+    }).on('exit', code => process.exit(code ?? 1));
 } else if (isRun) {
     // FORZAMOS EL MODO AGENTE: Esto saltará el menú interactivo en gen-and-run.mjs
     const mainScript = path.join(PACKAGE_ROOT, 'scripts', 'gen-and-run.mjs');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@arcadialdev/arcality",
-  "version": "2.6.6",
+  "version": "3.0.0",
   "description": "El primer ingeniero QA Autónomo integrado al CI/CD. Creado por Arcadial.",
   "main": "index.js",
   "scripts": {

package/playwright.config.js

@@ -3,19 +3,37 @@
 const { defineConfig, devices } = require('@playwright/test');
 const path = require('path');
 
+// ── Dynamic reporter: JUnit is added when running in CI (Azure DevOps, GitHub Actions) ──
+// The JUnit XML file enables native test result publishing in your pipeline dashboard.
+// In local/interactive mode, the JUnit reporter is skipped — only Arcality's HTML reporter runs.
+const reportsDir = process.env.REPORTS_DIR || path.join(__dirname, 'tests-report');
+const isCI = process.env.CI === 'true';
+
+const reporters = [
+    ['line'],
+    [path.join(__dirname, 'tests', '_helpers', 'ArcalityReporter.js'), { outputDir: reportsDir }],
+];
+
+if (isCI) {
+    reporters.push(['junit', { outputFile: path.join(reportsDir, 'results.xml') }]);
+}
+
 module.exports = defineConfig({
   testDir: path.join(__dirname, 'tests', '_helpers'),
   testMatch: ['agentic-runner.bundle.spec.js'],
-  reporter: [
-    ['line'],
-    [path.join(__dirname, 'tests', '_helpers', 'ArcalityReporter.js'),
-     { outputDir: process.env.REPORTS_DIR || path.join(__dirname, 'tests-report') }]
-  ],
+  reporter: reporters,
   use: {
+    // ── Dynamic BASE_URL ──
+    // Priority: CLI --base-url flag → arcality.config baseUrl → BASE_URL env → default
+    // This allows pipelines to inject the target environment dynamically:
+    //   arcality --run-all --base-url=https://staging.myapp.com
+    baseURL: process.env.BASE_URL || 'http://localhost:3000',
     video: 'on',
     screenshot: 'on',
     trace: 'on',
     colorScheme: 'dark',
+    // In CI: headless is enforced by Playwright automatically when CI=true
+    headless: isCI ? true : undefined,
     contextOptions: {
       reducedMotion: 'reduce',
     },
@@ -32,3 +50,4 @@ module.exports = defineConfig({
     },
   ],
 });
+

package/scripts/gen-and-run.mjs

@@ -162,7 +162,6 @@ function setupEnvironment() {
 
 function showBanner() {
     console.clear();
-    const projectName = 'Arcality';
 
     let version = 'unknown';
     try {
@@ -170,19 +169,22 @@ function showBanner() {
         version = pkg.version || 'unknown';
     } catch { }
 
-    const logo = figlet.textSync(projectName, {
-        font: 'Standard',
-        horizontalLayout: 'default',
-        verticalLayout: 'default',
-    });
+    const sentinelAscii = `
+ █████  ██████   ██████  █████  ██      ██ ████████ ██    ██ 
+██   ██ ██   ██ ██      ██   ██ ██      ██    ██     ██  ██  
+███████ ██████  ██      ███████ ██      ██    ██      ████   
+██   ██ ██   ██ ██      ██   ██ ██      ██    ██       ██    
+██   ██ ██   ██  ██████ ██   ██ ███████ ██    ██       ██    `;
 
-    intro(chalk.cyanBright(logo));
+    intro(chalk.gray(sentinelAscii));
 
     note(
-        chalk.magentaBright('Powered by Arcadial') + '\n' +
+        chalk.gray('◉ Motor de Observación: ') + chalk.bold.white('EN LÍNEA') + '\n' +
+        chalk.gray('◉ Módulo de Recuperación de UI: ') + chalk.bold.white('ACTIVO') + '\n' +
+        chalk.gray('◉ Lógica Forense:     ') + chalk.bold.white('ACTIVA') + '\n' +
         chalk.gray('─'.repeat(50)) + '\n' +
-        chalk.bold.white('📦 Version: ') + chalk.yellow(version),
-        'System Information'
+        chalk.gray('Versión del Sistema: ') + chalk.white(`v${version}`),
+        'Estado Central de Arcality'
     );
 
     const { configName, baseUrl, techStack, configDir } = setupEnvironment();
@@ -190,30 +192,30 @@ function showBanner() {
     // Show arcality.config status instead of multi-config switching
     const hasConfig = !!projectConfig;
     const configStatus = hasConfig
-        ? chalk.green('✅ Configured')
-        : chalk.red('❌ Not configured — run `arcality init`');
+        ? chalk.green('◉ Sincronización Establecida')
+        : chalk.red('⚠ Desconectado — Ejecuta `arcality init`');
 
     const { key: apiKeyVal, source: apiKeySource } = getApiKey();
     const apiKeyDisplay = apiKeyVal
-        ? chalk.green(maskApiKey(apiKeyVal)) + chalk.gray(` (${apiKeySource})`)
-        : chalk.red('Not configured');
+        ? chalk.green(maskApiKey(apiKeyVal)) + chalk.gray(` [${apiKeySource}]`)
+        : chalk.red('NO VERIFICADO');
 
     const infoLines = [
-        chalk.bold.white('⚙️  Environment: ') + chalk.yellow(process.env.NODE_ENV ?? 'development'),
-        chalk.bold.white('🔑 API Key: ') + apiKeyDisplay,
-        chalk.bold.white('🛠️  Stack: ') + chalk.magenta(techStack),
+        chalk.gray('Nodo Objetivo: ') + chalk.white(process.env.NODE_ENV ?? 'development'),
+        chalk.gray('Token de Autenticación:  ') + apiKeyDisplay,
+        chalk.gray('Stack:  ') + chalk.white(techStack),
     ];
 
     if (hasConfig) {
         infoLines.splice(1, 0,
-            chalk.bold.white('📋 Project: ') + chalk.cyan(configName) + chalk.gray(` (${baseUrl})`),
-            chalk.bold.white('🆔 Project ID: ') + chalk.gray(projectConfig.projectId || 'N/A'),
+            chalk.gray('Proyecto:     ') + chalk.white(configName) + chalk.gray(` [${baseUrl}]`),
+            chalk.gray('ID de Identidad: ') + chalk.white(projectConfig.projectId || 'N/A'),
         );
     } else {
-        infoLines.push(chalk.bold.white('📋 Config: ') + configStatus);
+        infoLines.push(chalk.gray('Configuración:      ') + configStatus);
     }
 
-    note(infoLines.join('\n'), 'Active Configuration');
+    note(infoLines.join('\n'), 'Telemetría del Objetivo');
 }
 
 const ARCALITY_BRAIN_URL = "https://api.anthropic.com/v1/messages";
@@ -496,21 +498,21 @@ async function main() {
                 const rootYamlFiles = fs.readdirSync(PROJECT_ROOT).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
 
                 const options = [
-                    { label: '🤖 Run Autonomous Agent (Prompt)', value: 'agent' },
-                    ...(savedMissions.length ? [{ label: '🚀 Launch Saved Mission (.yaml)', value: 'launch_saved' }] : []),
-                    ...(yamlOutputFiles.length ? [{ label: '♻️  Reuse YAML + Auto-Guide (if prev. run exists)', value: 'reuse_yaml' }] : []),
-                    ...(rootYamlFiles.length ? [{ label: '📂 Choose Root YAML (Templates)', value: 'yaml_list' }] : []),
-                    { label: '🔄 Reconfigure (arcality init)', value: 'reconfigure' },
-                    { label: '❌ Exit', value: 'exit' }
+                    { label: '◉  Desplegar Arcality (Prompt)', value: 'agent' },
+                    ...(savedMissions.length ? [{ label: '⟳  Lanzar Misión Archivada (.yaml)', value: 'launch_saved' }] : []),
+                    ...(yamlOutputFiles.length ? [{ label: '⟶  Activar Modo GUÍA (Reusar YAML)', value: 'reuse_yaml' }] : []),
+                    ...(rootYamlFiles.length ? [{ label: '📂  Cargar Matriz de Patrones (YAML Raíz)', value: 'yaml_list' }] : []),
+                    { label: '⚙  Recalibrar Sistema (init)', value: 'reconfigure' },
+                    { label: '✕  Terminar Proceso', value: 'exit' }
                 ];
 
                 const action = await select({
-                    message: 'What would you like to do?',
+                    message: '¿Qué te gustaría hacer?',
                     options
                 });
 
                 if (isCancel(action) || action === 'exit') {
-                    outro(chalk.cyan('See you later!'));
+                    outro(chalk.cyan('¡Hasta luego!'));
                     break;
                 }
 
@@ -546,7 +548,7 @@ async function main() {
                     continue;
                 } else if (action === 'launch_saved') {
                     const sel = await select({
-                        message: 'Choose saved mission:',
+                        message: 'Elige la misión guardada:',
                         options: savedMissions.map(f => ({ label: f, value: f }))
                     });
                     if (isCancel(sel)) continue;
@@ -558,7 +560,7 @@ async function main() {
                 } else if (action === 'reuse_yaml') {
                     const yamlDir = getYamlOutputDir(projectConfig, ORIGINAL_CWD);
                     const sel = await select({
-                        message: 'Choose YAML to reuse:',
+                        message: 'Elige el YAML a reusar:',
                         options: yamlOutputFiles.map(f => ({ label: f, value: f }))
                     });
                     if (isCancel(sel)) continue;
@@ -569,7 +571,7 @@ async function main() {
                     agentMode = true;
                 } else if (action === 'yaml_list') {
                     const sel = await select({
-                        message: 'Choose YAML file:',
+                        message: 'Elige el archivo YAML:',
                         options: rootYamlFiles.map(f => ({ label: f, value: f }))
                     });
                     if (isCancel(sel)) continue;
@@ -589,16 +591,16 @@ async function main() {
         if (agentMode) {
             if (!prompt || prompt.trim().length < 4) {
                 const p = await text({
-                    message: chalk.cyan('🤖 Mission for the Agent (Required):'),
-                    placeholder: 'E.g., Fill the signup form with random data',
+                    message: chalk.cyan('🤖 Misión para Arcality (Requerida):'),
+                    placeholder: 'Ej., Llena el formulario de registro con datos aleatorios',
                     validate: v => {
-                        if (!v || !v.trim()) return 'The mission is required to start.';
-                        if (v.trim().length < 4) return 'The mission must be more descriptive (minimum 4 characters).';
+                        if (!v || !v.trim()) return 'La misión es requerida para iniciar.';
+                        if (v.trim().length < 4) return 'La misión debe ser más descriptiva (mínimo 4 caracteres).';
                     }
                 });
 
                 if (isCancel(p)) {
-                    cancel('Mission cancelled. Returning to main menu...');
+                    cancel('Misión cancelada. Regresando al menú principal...');
                     agentMode = false;
                     prompt = "";
                     skipMenu = false;
@@ -611,19 +613,19 @@ async function main() {
                 const knownBaseUrl = projectConfig?.project?.baseUrl || process.env.BASE_URL;
                 const promptMsg = knownBaseUrl
                     ? `🌐 Initial navigation path (relative to ${knownBaseUrl}):`
-                    : '🌐 Full Navigation URL (e.g., http://localhost:3000/):';
+                    : '🌐 URL Completa de Navegación (ej., http://localhost:3000/):';
 
                 const d = await text({
                     message: chalk.cyan(promptMsg),
                     placeholder: knownBaseUrl ? '/' : 'http://localhost:3000/',
                     validate: v => {
-                        if (!knownBaseUrl && !v.startsWith('http')) return 'Please provide a full URL with http:// or https://';
+                        if (!knownBaseUrl && !v.startsWith('http')) return 'Por favor provee una URL completa con http:// o https://';
                         return undefined;
                     }
                 });
 
                 if (isCancel(d)) {
-                    cancel('Mission aborted. Returning to menu...');
+                    cancel('Misión abortada. Regresando al menú...');
                     agentMode = false;
                     prompt = "";
                     skipMenu = false;
@@ -653,12 +655,12 @@ async function main() {
             }
             if (!validation.valid) {
                 const errorMessages = {
-                    'no_api_key': '🔑 API Key not found.\n   Configure it via `arcality init` or in .env (ARCALITY_API_KEY)',
-                    'invalid_format': '🔑 Invalid API Key. It must start with "arc_"',
-                    'invalid_api_key': '🔑 API Key not recognized by the server',
-                    'plan_expired': '💳 Your plan has expired'
+                    'no_api_key': '🔑 API Key no encontrada.\n   Configúrala vía `arcality init` o en .env (ARCALITY_API_KEY)',
+                    'invalid_format': '🔑 API Key inválida. Debe comenzar con "arc_"',
+                    'invalid_api_key': '🔑 API Key no reconocida por el servidor',
+                    'plan_expired': '💳 Tu plan ha expirado'
                 };
-                note(chalk.red(errorMessages[validation.error] || `Error: ${validation.error}`), '❌ Authentication');
+                note(chalk.red(errorMessages[validation.error] || `Error: ${validation.error}`), '❌ Autenticación');
                 agentMode = false;
                 prompt = "";
                 skipMenu = false;
@@ -666,15 +668,15 @@ async function main() {
             }
 
             // Show plan info
-            const modeLabel = validation.mode === 'mock' ? chalk.gray('(local)') : chalk.green('(live)');
+            const modeLabel = validation.mode === 'mock' ? chalk.gray('[sandbox]') : chalk.cyanBright('[live-net]');
             const dailyLimitDisplay = validation.daily_limit === -1 ? '∞' : (validation.daily_limit || 35);
             const remainingDisplay = validation.remaining >= 999999 ? '∞' : validation.remaining;
             note(
-                chalk.bold.white('✅ Valid API Key ') + modeLabel + '\n' +
-                chalk.bold.white('📋 Plan: ') + chalk.cyan(validation.plan || 'internal') + '\n' +
-                chalk.bold.white('📊 Missions today: ') + chalk.yellow(`${validation.daily_used || 0}/${dailyLimitDisplay}`) + '\n' +
-                chalk.bold.white('🎯 Remaining: ') + chalk.green(remainingDisplay),
-                'Arcality Account'
+                chalk.gray('Conexión: ') + chalk.cyanBright('SECURE ') + modeLabel + '\n' +
+                chalk.gray('Autorización: ') + chalk.white(validation.plan || 'internal') + '\n' +
+                chalk.gray('Misiones:   ') + chalk.white(`${validation.daily_used || 0}/${dailyLimitDisplay}`) + '\n' +
+                chalk.gray('Reservas:   ') + chalk.white(remainingDisplay),
+                'Enlace Arcality'
             );
 
             // --- RESOLVE PROJECT ID ---
@@ -697,21 +699,21 @@ async function main() {
                         const projects = data.projects || [];
 
                         const projOptions = projects.map(p => ({ label: p.name || p.Name, value: p.id || p.Id }));
-                        projOptions.push({ label: '➕ Create new project', value: 'new' });
+                        projOptions.push({ label: '➕ Crear nuevo proyecto', value: 'new' });
 
                         const projSelection = await select({
-                            message: chalk.cyan('Choose a project for this mission:'),
+                            message: chalk.cyan('Elige un proyecto para esta misión:'),
                             options: projOptions
                         });
 
                         if (isCancel(projSelection)) {
-                            cancel('Mission aborted.');
+                            cancel('Misión abortada.');
                             agentMode = false; prompt = ""; skipMenu = false; continue;
                         }
 
                         if (projSelection === 'new') {
-                            const newName = await text({ message: 'Project name:', validate: v => !v ? 'Required' : undefined });
-                            if (isCancel(newName)) { cancel('Aborted'); agentMode = false; prompt = ""; skipMenu = false; continue; }
+                            const newName = await text({ message: 'Nombre del proyecto:', validate: v => !v ? 'Requerido' : undefined });
+                            if (isCancel(newName)) { cancel('Abortado'); agentMode = false; prompt = ""; skipMenu = false; continue; }
 
                             const createRes = await fetch(`${apiBase}/api/v1/projects`, {
                                 method: 'POST',
@@ -727,9 +729,9 @@ async function main() {
                             if (createRes.ok) {
                                 const created = await createRes.json();
                                 selectedProjectId = created.id || created.Id;
-                                note(chalk.green(`✅ Project created: ${newName}`));
+                                note(chalk.green(`✅ Proyecto creado: ${newName}`));
                             } else {
-                                note(chalk.red(`❌ Failed to create project.`));
+                                note(chalk.red(`❌ Falló al crear proyecto.`));
                             }
                         } else {
                             selectedProjectId = projSelection;
@@ -750,10 +752,10 @@ async function main() {
             const mission = await requestMission(prompt, discoverPath || '/');
             if (!mission.allowed) {
                 note(
-                    chalk.red(`❌ ${mission.error === 'mission_limit_exceeded' ? 'Daily mission limit reached' : mission.error}`) + '\n' +
+                    chalk.red(`❌ ${mission.error === 'mission_limit_exceeded' ? 'Límite diario de misiones alcanzado' : mission.error}`) + '\n' +
                     chalk.yellow(`📊 Used: ${mission.daily_used}/${mission.daily_limit}`) + '\n' +
                     chalk.gray(`🔄 Resets: ${mission.resets_at ? new Date(mission.resets_at).toLocaleString() : 'tomorrow'}`),
-                    '⚠️ Limit Reached'
+                    '⚠️ Límite Alcanzado'
                 );
                 agentMode = false;
                 prompt = "";
@@ -763,9 +765,9 @@ async function main() {
 
             const s = spinner();
             if (!process.argv.includes('--debug')) {
-                s.start(`🤖 [AGENT MODE] Starting mission: "${prompt}" ${chalk.gray(`(${mission.daily_used}/${mission.daily_limit} today)`)}`);
+                s.start(`◉ [ARCALITY INICIADO] Ejecutando directiva: "${prompt}" ${chalk.gray(`(${mission.daily_used}/${mission.daily_limit})`)}`);
             } else {
-                console.log(chalk.cyan(`\n🤖 [AGENT MODE] Starting mission: "${prompt}" ${chalk.gray(`(${mission.daily_used}/${mission.daily_limit} today)`)}`));
+                console.log(chalk.cyan(`\n◉ [ARCALITY INICIADO] Ejecutando directiva: "${prompt}" ${chalk.gray(`(${mission.daily_used}/${mission.daily_limit})`)}`));
             }
 
             const finalProjectId = process.env.ARCALITY_PROJECT_ID || selectedProjectId;
@@ -821,9 +823,9 @@ async function main() {
                 }
                 userCanceledMission = true;
 
-                console.log(chalk.yellow('\n\n⚠️  [ARCALITY] Misión cancelada por el usuario.'));
+                console.log(chalk.yellow('\n\n⚠️  [ARCALITY] Directiva abortada por el operador.'));
                 if (!process.argv.includes('--debug')) {
-                    try { s.stop(chalk.yellow('⚠️  Misión cancelada.')); } catch { /* ignore */ }
+                    try { s.stop(chalk.yellow('⚠️  Directiva abortada.')); } catch { /* ignore */ }
                 }
 
                 // Terminar el proceso hijo de Playwright directamente (Windows-safe)
@@ -842,7 +844,7 @@ async function main() {
                     if (ctxDir && fs.existsSync(ctxDir)) {
                         const cancelLog = {
                             prompt,
-                            history: ['[CANCELADO POR USUARIO] La prueba fue detenida manualmente antes de completarse.'],
+                            history: ['[ABORTO DEL OPERADOR] La directiva fue detenida manualmente antes de completarse.'],
                             steps: 0,
                             success: false,
                             error: true,
@@ -850,7 +852,7 @@ async function main() {
                             canceled_by_user: true,
                             timestamp: new Date().toISOString()
                         };
-                        fs.writeFileSync(path.join(ctxDir, `agent-log-${Date.now()}.json`), JSON.stringify(cancelLog, null, 2));
+                        fs.writeFileSync(path.join(ctxDir, `arcality-log-${Date.now()}.json`), JSON.stringify(cancelLog, null, 2));
                     }
                 } catch { /* silencioso */ }
 
@@ -958,21 +960,34 @@ async function main() {
                     console.log(chalk.gray(`[DEBUG] Using playwright CLI: ${playwrightCli}`));
                 }
             } catch (e) {
-                console.error(chalk.red('\n[FATAL] Playwright core not found. Make sure @playwright/test is installed.'));
+                console.error(chalk.red('\n[FATAL] Núcleo de Playwright no encontrado. Asegúrate de que @playwright/test esté instalado.'));
                 console.error(chalk.red(e.message));
-                console.error(chalk.yellow('\nTip: Run `npm install @playwright/test` in your project directory.'));
+                console.error(chalk.yellow('\nConsejo: Ejecuta `npm install @playwright/test` en tu directorio de proyecto.'));
                 _missionActive = false;
                 process.exit = _origProcessExit;
                 _origProcessExit(1);
             }
 
-            const postProcessSigint = () => console.log(chalk.yellow('\n⏳ Finalizando tareas de reporte, por favor espera...'));
+            const postProcessSigint = () => console.log(chalk.yellow('\n⏳ Finalizando reporte de telemetría, por favor espera...'));
             let missionResult = null;
             let finalFailReason = null;
             let finalUsageData = undefined;
             let finalReportUrl = null;
             let finalFailReasoning = null;
 
+            // ── Auto-compilar el runner antes de ejecutar Playwright para asegurar que los cambios de rama/merge estén aplicados ──
+            try {
+                if (!process.argv.includes('--debug')) {
+                    s.message('⚙️  Compilando agente de pruebas (Arcality Runner)...');
+                } else {
+                    console.log(chalk.cyan('⚙️  Compilando agente de pruebas (Arcality Runner)...'));
+                }
+                const npmCmd = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+                await run(npmCmd, ['run', 'build:runner'], { cwd: PROJECT_ROOT });
+            } catch (err) {
+                console.warn(chalk.yellow(`\n⚠️  Advertencia: No se pudo auto-compilar el runner: ${err.message}`));
+            }
+
             try {
                 // No test file path is passed — playwright.config.js uses testMatch:'agentic-runner.spec.ts'
                 // This eliminates the Windows regex path issue permanently on any user's machine.
@@ -1005,26 +1020,26 @@ async function main() {
                 }
 
                 missionResult = 'success';
-                if (!process.argv.includes('--debug')) s.stop(chalk.green('✅ Mission completed successfully.'));
-                else console.log(chalk.green('✅ Mission completed successfully.'));
+                if (!process.argv.includes('--debug')) s.stop(chalk.green('✅ Misión completada exitosamente.'));
+                else console.log(chalk.green('✅ Misión completada exitosamente.'));
 
                 // ── Ping Project ──
                 await pingProject(finalProjectId, process.env.ARCALITY_API_KEY);
 
                 // ── Save Mission YAML ──
                 const saveDecision = await select({
-                    message: 'Do you want to save this mission to run it again later?',
+                    message: '¿Quieres guardar esta misión para ejecutarla de nuevo más tarde?',
                     options: [
-                        { label: '✅ Yes, save as YAML', value: 'yes' },
-                        { label: '❌ No, thanks', value: 'no' }
+                        { label: '✅ Sí, guardar como YAML', value: 'yes' },
+                        { label: '❌ No, gracias', value: 'no' }
                     ]
                 });
 
                 if (saveDecision === 'yes') {
                     const name = await text({
-                        message: 'Mission name (e.g., valid_login):',
+                        message: 'Nombre de la misión (ej., login_valido):',
                         placeholder: 'my_mission',
-                        validate: v => v.length < 3 ? 'Name too short' : undefined
+                        validate: v => v.length < 3 ? 'Nombre muy corto' : undefined
                     });
 
                     if (!isCancel(name)) {
@@ -1050,9 +1065,9 @@ async function main() {
                             const yamlOutputDir = ensureYamlOutputDir(projectConfig, ORIGINAL_CWD);
                             const yamlPathOutput = path.join(yamlOutputDir, `${safeName}.yaml`);
                             fs.writeFileSync(yamlPathOutput, yamlData);
-                            note(chalk.green(`✅ Mission saved at: ${yamlPathOutput}`), 'Arcality Persistence');
+                            note(chalk.green(`✅ Misión guardada en: ${yamlPathOutput}`), 'Persistencia Arcality');
                         } else {
-                            note(chalk.green(`✅ Mission saved at: ${yamlPathMissions}`), 'Arcality Persistence');
+                            note(chalk.green(`✅ Misión guardada en: ${yamlPathMissions}`), 'Persistencia Arcality');
                         }
                     }
                 }
@@ -1061,12 +1076,12 @@ async function main() {
                 if (userCanceledMission) {
                     missionResult = 'canceled';
                     finalFailReason = 'user_canceled';
-                    console.log(chalk.yellow('\n⚠️  Misión cancelada — generando reporte de evidencia...'));
+                    console.log(chalk.yellow('\n⚠️  Directiva abortada — generando reporte de evidencia...'));
                 } else {
                     missionResult = 'failed';
                     finalFailReason = 'timeout_or_crash';
-                    s.stop(chalk.red(`❌ Mission could not be completed.`));
-                    console.error(chalk.red(`\nError Details: ${e.message}`));
+                    s.stop(chalk.red(`❌ Arcality no pudo completar la directiva.`));
+                    console.error(chalk.red(`\nDetalles del Error: ${e.message}`));
                     if (e.stack && process.argv.includes('--debug')) {
                         console.error(chalk.gray(e.stack));
                     }
@@ -1081,7 +1096,7 @@ async function main() {
                 if (userCanceledMission) {
                     missionResult = 'canceled';
                     finalFailReason = 'user_canceled';
-                    finalFailReasoning = 'La misión fue detenida manualmente por el usuario (Ctrl+C) antes de completarse. No se trata de un fallo técnico del sistema ni del portal.';
+                    finalFailReasoning = 'La misión fue detenida manualmente por el operador (Ctrl+C). Esto no es una falla técnica del sistema.';
                     await new Promise(r => setTimeout(r, 800));
                 }
 
@@ -1090,9 +1105,9 @@ async function main() {
 
                 const sRep = spinner();
                 if (!process.argv.includes('--debug')) {
-                    sRep.start('📊 Generating report...');
+                    sRep.start('📊 Generando reporte...');
                 } else {
-                    console.log('📊 Generating report...');
+                    console.log('📊 Generando reporte...');
                 }
 
                 await run("node", [path.join(PROJECT_ROOT, "scripts/rebrand-report.mjs")]).catch(() => { });
@@ -1107,7 +1122,7 @@ async function main() {
                     const ctxDir = process.env.CONTEXT_DIR;
                     if (fs.existsSync(ctxDir)) {
                         const files = fs.readdirSync(ctxDir);
-                        const logFiles = files.filter(f => f.startsWith('agent-log-') && f.endsWith('.json')).sort();
+                        const logFiles = files.filter(f => f.startsWith('arcality-log-') && f.endsWith('.json')).sort();
                         if (logFiles.length > 0) {
                             const lastLog = path.join(ctxDir, logFiles[logFiles.length - 1]);
                             const logData = JSON.parse(fs.readFileSync(lastLog, 'utf8'));
@@ -1134,7 +1149,7 @@ async function main() {
 
                         if (sasData && actualSasUrl && actualBasePath) {
                             if (!process.argv.includes('--debug')) {
-                                sRep.start('☁️  Uploading evidence to Azure...');
+                                sRep.start('☁️  Subiendo evidencia a Azure...');
                             }
                             process.removeAllListeners('SIGINT');
                             process.removeAllListeners('SIGTERM');
@@ -1148,14 +1163,14 @@ async function main() {
                                 finalReportUrl = `${parsedSas.origin}${parsedSas.pathname}/${actualBasePath}/index.html`;
                             } catch(e) {}
 
-                            if (!process.argv.includes('--debug')) sRep.stop(chalk.green('✅ Evidence uploaded successfully.'));
+                            if (!process.argv.includes('--debug')) sRep.stop(chalk.green('✅ Evidencia subida exitosamente.'));
                         }
                     } catch (e) {
                         if (process.argv.includes('--debug')) console.log(chalk.yellow(`⚠️  Could not upload evidence: ${e.message}`));
-                        if (!process.argv.includes('--debug')) sRep.stop(chalk.yellow('⚠️  Evidence upload failed.'));
+                        if (!process.argv.includes('--debug')) sRep.stop(chalk.yellow('⚠️  Fallo al subir evidencia.'));
                     }
                 } else {
-                    console.log(chalk.gray('   >> Skipping evidence upload (mission was canceled).'));
+                    console.log(chalk.gray('   >> Saltando subida de evidencia (la misión fue cancelada).'));
                 }
 
                 // ── End Mission — SIEMPRE se llama, independientemente de si la evidencia subió ──
@@ -1179,14 +1194,14 @@ async function main() {
                 }
 
                 if (fs.existsSync(arcalityPath)) {
-                    console.log(chalk.blue(`🌐 Opening Arcality Report: ${arcalityPath}`));
+                    console.log(chalk.blue(`🌐 Abriendo Reporte de Arcality: ${arcalityPath}`));
                     if (process.platform === "win32") {
                         exec(`start "" "${arcalityPath}"`);
                     } else {
                         exec(`open "${arcalityPath}"`);
                     }
                 } else {
-                    console.log(chalk.yellow(`⚠️  Report not generated (test may have crashed before completing).`));
+                    console.log(chalk.yellow(`⚠️  Reporte no generado (la prueba pudo haber fallado antes de completarse).`));
                 }
 
                 await new Promise(resolve => setTimeout(resolve, 2000));
@@ -1197,10 +1212,14 @@ async function main() {
                     process.env.ARCALITY_API_KEY
                 );
 
+                // Limpiar handlers del post-proceso ANTES de esperar Enter, ya que toda la telemetría y reportes ya finalizaron
+                process.removeListener('SIGINT', postProcessSigint);
+                process.removeListener('SIGTERM', postProcessSigint);
+
                 // Esperar Enter para regresar al menú
                 // Usamos escucha directa de stdin (raw mode) porque @clack/text
                 // no procesa Enter correctamente cuando setRawMode(true) está activo.
-                console.log(chalk.gray('\n   Press Enter to return to menu...'));
+                console.log(chalk.gray('\n   Presiona Enter para regresar al menú...'));
                 await new Promise(resolve => {
                     const onKey = (key) => {
                         const keyStr = String(key);
@@ -1211,10 +1230,17 @@ async function main() {
                             if (process.stdin.isTTY && process.stdin.setRawMode) {
                                 process.stdin.setRawMode(false);
                             }
-                            process.stdin.pause();
+                            // FIX: pausar stdin si vamos a salir para que el event loop no se quede colgado.
+                            // Si volvemos al menú, no lo pausamos (para evitar el bug de exit en clack).
+                            if (skipMenu) {
+                                process.stdin.pause();
+                            }
 
-                            if (keyStr === '\u0003') process.emit('SIGINT'); // Ctrl+C = salir
-                            else resolve();
+                            if (keyStr === '\u0003') {
+                                process.exit(0); // Ctrl+C = salir inmediatamente
+                            } else {
+                                resolve();
+                            }
                         }
                     };
 
@@ -1232,17 +1258,13 @@ async function main() {
                 });
 
                 if (skipMenu) {
-                    outro(chalk.cyan('Mission finished! See you later.'));
+                    outro(chalk.cyan('¡Misión terminada! Hasta luego.'));
                     return;
                 }
 
                 agentMode = false;
                 prompt = "";
                 firstRun = false;
-
-                // Limpiar handlers del post-proceso
-                process.removeListener('SIGINT', postProcessSigint);
-                process.removeListener('SIGTERM', postProcessSigint);
             }
         }
         firstRun = false;