@arcadialdev/arcality 2.6.7 → 3.0.1

package/scripts/gen-and-run.mjs

@@ -119,7 +119,7 @@ function updateDotEnvFile(updates) {
     keys.forEach(k => { process.env[k] = updates[k]; });
 }
 
-function setupEnvironment() {
+function setupEnvironment() {
 
     // Use config name from arcality.config or fallback
     const configName = projectConfig?.project?.name || 'Default';
@@ -133,14 +133,16 @@ function setupEnvironment() {
     process.env.CONTEXT_DIR = path.join(configDir, 'context');
     process.env.REPORTS_DIR = path.join(configDir, 'reports');
 
-    [process.env.MISSIONS_DIR, process.env.CONTEXT_DIR, process.env.REPORTS_DIR].forEach(dir => {
-        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
-    });
-
-    // Also ensure YAML output dir from arcality.config
-    if (projectConfig) {
-        ensureYamlOutputDir(projectConfig, ORIGINAL_CWD);
-    }
+    [process.env.MISSIONS_DIR, process.env.CONTEXT_DIR, process.env.REPORTS_DIR].forEach(dir => {
+        if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+    });
+    ensureMissionTemplates(process.env.MISSIONS_DIR);
+
+    // Also ensure YAML output dir from arcality.config
+    if (projectConfig) {
+        const yamlOutputDir = ensureYamlOutputDir(projectConfig, ORIGINAL_CWD);
+        ensureMissionTemplates(yamlOutputDir);
+    }
 
     // Framework detection from package.json (NO .git)
     let techStack = 'Not detected';
@@ -157,12 +159,614 @@ function setupEnvironment() {
         techStack = projectConfig.project.frameworkDetected;
     }
 
-    return { configName, baseUrl, techStack, configDir };
-}
-
-function showBanner() {
+    return { configName, baseUrl, techStack, configDir };
+}
+
+function isYamlFile(fileName) {
+    return fileName.endsWith('.yaml') || fileName.endsWith('.yml');
+}
+
+function isCollectionMetaFile(fileName) {
+    const lower = String(fileName || '').toLowerCase();
+    return lower === '_collection.yaml' || lower === '_collection.yml';
+}
+
+function isSystemCollectionDir(dirName) {
+    return String(dirName || '').toLowerCase() === '_templates';
+}
+
+function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+
+function sanitizePathSegment(segment) {
+    return String(segment || '')
+        .trim()
+        .replace(/[^a-zA-Z0-9_-]/g, '_')
+        .replace(/_+/g, '_')
+        .replace(/^_+|_+$/g, '')
+        .toLowerCase();
+}
+
+function sanitizeCollectionPath(input) {
+    const segments = String(input || '')
+        .split(/[\\/]+/)
+        .map(sanitizePathSegment)
+        .filter(Boolean);
+
+    return segments.join(path.sep);
+}
+
+function listYamlFilesInDir(dir) {
+    if (!dir || !fs.existsSync(dir)) return [];
+    return fs.readdirSync(dir, { withFileTypes: true })
+        .filter(entry => entry.isFile() && isYamlFile(entry.name) && !isCollectionMetaFile(entry.name))
+        .map(entry => entry.name)
+        .sort((a, b) => a.localeCompare(b));
+}
+
+function readYamlFile(filePath) {
+    try {
+        return loadYaml(fs.readFileSync(filePath, 'utf8'));
+    } catch {
+        return null;
+    }
+}
+
+function normalizeStringList(value) {
+    if (Array.isArray(value)) {
+        return value.map(v => String(v).trim()).filter(Boolean);
+    }
+    if (typeof value === 'string') {
+        return value.split(',').map(v => v.trim()).filter(Boolean);
+    }
+    return [];
+}
+
+function readCollectionMeta(dir, rel = '') {
+    const candidates = ['_collection.yaml', '_collection.yml']
+        .map(name => path.join(dir, name))
+        .filter(fs.existsSync);
+
+    if (candidates.length === 0) {
+        return {
+            label: rel ? toPosixPath(rel) : 'General (sin carpeta)',
+            description: '',
+            tags: []
+        };
+    }
+
+    const raw = readYamlFile(candidates[0]);
+    const meta = raw && typeof raw === 'object' ? raw : {};
+    return {
+        label: String(meta.name || meta.title || (rel ? toPosixPath(rel) : 'General (sin carpeta)')).trim(),
+        description: String(meta.description || '').trim(),
+        tags: normalizeStringList(meta.tags),
+        defaultPagePath: String(meta.default_page_path || meta.defaultPagePath || meta.start_at || meta.StartAt || '').trim()
+    };
+}
+
+function normalizeMissionSpec(rawMission, filePath = '') {
+    const mission = rawMission && typeof rawMission === 'object' ? rawMission : {};
+    const fallbackName = filePath ? path.basename(filePath, path.extname(filePath)) : 'mission';
+    const prompt = String(
+        mission.prompt ||
+        mission.mision ||
+        mission.task ||
+        ''
+    ).trim();
+
+    return {
+        raw: mission,
+        name: String(mission.name || fallbackName).trim(),
+        prompt,
+        page: String(mission.page || '').trim(),
+        pagePath: String(mission.page_path || mission.pagePath || '').trim(),
+        startAt: String(mission.start_at || mission.startAt || mission.StartAt || '').trim(),
+        expectedResult: String(mission.expected_result || mission.expectedResult || '').trim(),
+        collection: String(mission.collection || '').trim(),
+        suite: String(mission.suite || '').trim(),
+        priority: String(mission.priority || '').trim(),
+        tags: normalizeStringList(mission.tags),
+        timeout: Number.isFinite(Number(mission.timeout)) ? Number(mission.timeout) : null,
+        credentialId: String(mission.credential_id || mission.credentialId || '').trim()
+    };
+}
+
+function listMissionCollections(rootDir) {
+    if (!rootDir || !fs.existsSync(rootDir)) return [];
+
+    const collections = [];
+    const visit = (dir, rel = '') => {
+        const yamlFiles = listYamlFilesInDir(dir);
+        const meta = readCollectionMeta(dir, rel);
+        if (yamlFiles.length > 0) {
+            collections.push({
+                label: meta.label,
+                description: meta.description,
+                tags: meta.tags,
+                value: rel,
+                dir,
+                count: yamlFiles.length
+            });
+        }
+
+        const subdirs = fs.readdirSync(dir, { withFileTypes: true })
+            .filter(entry => entry.isDirectory() && !isSystemCollectionDir(entry.name))
+            .map(entry => entry.name)
+            .sort((a, b) => a.localeCompare(b));
+
+        for (const subdir of subdirs) {
+            visit(path.join(dir, subdir), rel ? path.join(rel, subdir) : subdir);
+        }
+    };
+
+    visit(rootDir);
+    return collections;
+}
+
+function listMissionDirectories(rootDir) {
+    if (!rootDir || !fs.existsSync(rootDir)) return [];
+
+    const dirs = [];
+    const visit = (dir, rel = '') => {
+        const meta = readCollectionMeta(dir, rel);
+        dirs.push({
+            label: meta.label,
+            description: meta.description,
+            tags: meta.tags,
+            value: rel,
+            dir
+        });
+
+        const subdirs = fs.readdirSync(dir, { withFileTypes: true })
+            .filter(entry => entry.isDirectory() && !isSystemCollectionDir(entry.name))
+            .map(entry => entry.name)
+            .sort((a, b) => a.localeCompare(b));
+
+        for (const subdir of subdirs) {
+            visit(path.join(dir, subdir), rel ? path.join(rel, subdir) : subdir);
+        }
+    };
+
+    visit(rootDir);
+    return dirs;
+}
+
+async function selectMissionYaml(rootDir, collectionMessage = 'Elige la carpeta de misiones:', missionMessage = 'Elige la mision guardada:') {
+    const collections = listMissionCollections(rootDir);
+    if (collections.length === 0) return null;
+
+    let collection = collections[0];
+    if (collections.length > 1) {
+        const selectedCollection = await select({
+            message: collectionMessage,
+            options: collections.map(c => ({
+                label: `${c.label} (${c.count})${c.description ? ` - ${c.description}` : ''}`,
+                value: c.value
+            }))
+        });
+        if (isCancel(selectedCollection)) return null;
+        collection = collections.find(c => c.value === selectedCollection) || collection;
+    }
+
+    const files = listYamlFilesInDir(collection.dir);
+    const selectedFile = await select({
+        message: missionMessage,
+        options: files.map(file => {
+            const missionSpec = normalizeMissionSpec(readYamlFile(path.join(collection.dir, file)), file);
+            const labelParts = [missionSpec.name || file];
+            if (missionSpec.priority) labelParts.push(`[${missionSpec.priority}]`);
+            if (missionSpec.tags.length > 0) labelParts.push(`{${missionSpec.tags.join(', ')}}`);
+            return { label: labelParts.join(' '), value: file };
+        })
+    });
+    if (isCancel(selectedFile)) return null;
+
+    return {
+        collection: collection.value,
+        file: selectedFile,
+        fullPath: path.join(collection.dir, selectedFile),
+        collectionLabel: collection.label
+    };
+}
+
+async function selectSavedMissionSource({ libraryDir, projectDir, rootDir }) {
+    const sources = [];
+
+    const libraryCollections = listMissionCollections(libraryDir);
+    if (libraryCollections.length > 0) {
+        sources.push({
+            key: 'library',
+            label: 'Biblioteca Arcality',
+            description: 'Misiones archivadas por Arcality',
+            dir: libraryDir
+        });
+    }
+
+    const projectCollections = projectDir ? listMissionCollections(projectDir) : [];
+    if (projectCollections.length > 0) {
+        sources.push({
+            key: 'project',
+            label: 'Carpeta del proyecto',
+            description: 'Misiones guardadas junto al proyecto',
+            dir: projectDir
+        });
+    }
+
+    const rootMissionFiles = rootDir && fs.existsSync(rootDir)
+        ? fs.readdirSync(rootDir).filter(file => isYamlFile(file))
+        : [];
+    if (rootMissionFiles.length > 0) {
+        sources.push({
+            key: 'root',
+            label: 'Raiz del proyecto',
+            description: 'Archivos de mision ubicados en la raiz',
+            dir: rootDir,
+            files: rootMissionFiles
+        });
+    }
+
+    if (sources.length === 0) return null;
+
+    let source = sources[0];
+    if (sources.length > 1) {
+        const selectedSource = await select({
+            message: '¿De dónde quieres abrir la misión?',
+            options: sources.map(item => ({
+                label: `${item.label}${item.description ? ` - ${item.description}` : ''}`,
+                value: item.key
+            }))
+        });
+        if (isCancel(selectedSource)) return null;
+        source = sources.find(item => item.key === selectedSource) || source;
+    }
+
+    if (source.key === 'root') {
+        const selectedFile = await select({
+            message: 'Elige la misión guardada:',
+            options: source.files.map(file => ({ label: file, value: file }))
+        });
+        if (isCancel(selectedFile)) return null;
+
+        return {
+            source: source.label,
+            collection: '',
+            collectionLabel: source.label,
+            file: selectedFile,
+            fullPath: path.join(source.dir, selectedFile)
+        };
+    }
+
+    const selectedMission = await selectMissionYaml(
+        source.dir,
+        `Elige la carpeta de ${source.label.toLowerCase()}:`,
+        'Elige la misión guardada:'
+    );
+
+    if (!selectedMission) return null;
+
+    return {
+        ...selectedMission,
+        source: source.label
+    };
+}
+
+async function selectMissionSaveDir(rootDir) {
+    if (!fs.existsSync(rootDir)) fs.mkdirSync(rootDir, { recursive: true });
+
+    const directories = listMissionDirectories(rootDir);
+    const createNewValue = '__CREATE_NEW_COLLECTION__';
+    const selectedDir = await select({
+        message: 'Carpeta para guardar la mision:',
+        options: [
+            ...directories.map(d => ({
+                label: `${d.label}${d.description ? ` - ${d.description}` : ''}`,
+                value: d.value
+            })),
+            { label: '+ Crear nueva carpeta', value: createNewValue }
+        ]
+    });
+
+    if (isCancel(selectedDir)) return null;
+
+    let relDir = selectedDir;
+    if (selectedDir === createNewValue) {
+        const newDir = await text({
+            message: 'Nombre de la nueva carpeta (ej., smoke/login):',
+            placeholder: 'regression/login',
+            validate: v => {
+                if (!v || !v.trim()) return 'El nombre de la carpeta es requerido.';
+                if (!sanitizeCollectionPath(v)) return 'Usa letras, numeros, guiones o diagonales.';
+            }
+        });
+        if (isCancel(newDir)) return null;
+        relDir = sanitizeCollectionPath(newDir);
+    }
+
+    const targetDir = relDir ? path.join(rootDir, relDir) : rootDir;
+    fs.mkdirSync(targetDir, { recursive: true });
+    return { relDir, targetDir };
+}
+
+function ensureMissionTemplates(rootDir) {
+    if (!rootDir) return [];
+    const templatesDir = path.join(rootDir, '_templates');
+    if (!fs.existsSync(templatesDir)) fs.mkdirSync(templatesDir, { recursive: true });
+
+    const missionTemplatePath = path.join(templatesDir, 'mission.template.yaml');
+    const collectionTemplatePath = path.join(templatesDir, 'collection.template.yaml');
+    const created = [];
+
+    const missionTemplate = `# Arcality mission template
+# Use this file as a base when you want to create your own tests manually.
+#
+# name:
+# Friendly mission name shown in future menus and reports.
+name: "TS_registrar_timesheet_hoy"
+#
+# prompt:
+# Main instruction Arcality will execute. Be explicit about the expected flow.
+prompt: "Inicia sesion, abre el primer pendiente y registra un timesheet valido."
+#
+# page_path:
+# Relative route where the mission should begin. It is resolved against BASE_URL.
+page_path: "/welcome"
+#
+# project:
+# Optional project label for traceability.
+project: "MiProyectoQA"
+#
+# collection:
+# Logical folder/category for the mission library.
+collection: "timesheets/hoy"
+#
+# suite:
+# High-level group used for future batch execution and reporting.
+suite: "timesheets"
+#
+# tags:
+# Free-form labels for filtering and organization.
+tags:
+  - "smoke"
+  - "timesheets"
+#
+# priority:
+# Suggested values: low, normal, high, critical
+priority: "normal"
+#
+# expected_result:
+# Short statement describing what proves success.
+expected_result: "El registro nuevo aparece en la tabla Timesheet - Hoy."
+#
+# credential_id:
+# Optional placeholder for future centralized credentials.
+credential_id: ""
+#
+# hooks:
+# Reserved for future before/after automation hooks.
+# hooks:
+#   before: []
+#   after: []
+created_at: "2026-01-01T00:00:00.000Z"
+`;
+
+    const collectionTemplate = `# Arcality collection template
+# Save this as _collection.yaml inside a mission folder to customize how the folder is shown.
+#
+# name:
+# Friendly collection name displayed in menus.
+name: "Timesheets diarios"
+#
+# description:
+# One-line explanation for users choosing the collection.
+description: "Misiones para registrar y validar timesheets del dia."
+#
+# tags:
+# Optional labels inherited conceptually by the collection.
+tags:
+  - "timesheets"
+  - "daily"
+#
+# default_page_path:
+# Optional fallback route used when a mission in this folder does not define page_path.
+default_page_path: "/welcome"
+`;
+
+    if (!fs.existsSync(missionTemplatePath)) {
+        fs.writeFileSync(missionTemplatePath, missionTemplate, 'utf8');
+        created.push(missionTemplatePath);
+    }
+    if (!fs.existsSync(collectionTemplatePath)) {
+        fs.writeFileSync(collectionTemplatePath, collectionTemplate, 'utf8');
+        created.push(collectionTemplatePath);
+    }
+
+    return created;
+}
+
+async function waitForEnter(message = 'Presiona Enter para continuar...') {
+    if (!process.stdin.isTTY) return;
+
+    console.log(chalk.gray(`\n   ${message}`));
+    await new Promise(resolve => {
+        const onKey = (key) => {
+            const keyStr = String(key);
+            if (keyStr.includes('\r') || keyStr.includes('\n') || keyStr === '\u0003') {
+                process.stdin.off('data', onKey);
+
+                if (process.stdin.isTTY && process.stdin.setRawMode) {
+                    process.stdin.setRawMode(false);
+                }
+
+                if (keyStr === '\u0003') {
+                    process.exit(0);
+                } else {
+                    resolve();
+                }
+            }
+        };
+
+        if (process.stdin.isTTY && process.stdin.setRawMode) {
+            process.stdin.setRawMode(true);
+        }
+        process.stdin.resume();
+        process.stdin.on('data', onKey);
+    });
+}
+
+function getMissionStartPath(missionSpec, collectionMeta = null, fallbackPath = '') {
+    return missionSpec.pagePath || missionSpec.startAt || missionSpec.page || collectionMeta?.defaultPagePath || fallbackPath;
+}
+
+function listMissionLogFiles(contextDir) {
+    if (!contextDir || !fs.existsSync(contextDir)) return [];
+    return fs.readdirSync(contextDir)
+        .filter(file => (
+            (file.startsWith('agent-log-') || file.startsWith('arcality-log-')) &&
+            file.endsWith('.json')
+        ))
+        .sort();
+}
+
+function readLatestMissionLog(contextDir, knownFiles = new Set()) {
+    const files = listMissionLogFiles(contextDir);
+    const newFiles = files.filter(file => !knownFiles.has(file));
+    const targetFile = (newFiles.length > 0 ? newFiles[newFiles.length - 1] : files[files.length - 1]);
+    if (!targetFile) return null;
+
+    try {
+        const fullPath = path.join(contextDir, targetFile);
+        return {
+            file: fullPath,
+            data: JSON.parse(fs.readFileSync(fullPath, 'utf8'))
+        };
+    } catch {
+        return null;
+    }
+}
+
+async function runCollectionBatch({
+    missionsRootDir,
+    selectedCollection = null,
+    debug = false
+}) {
+    const collections = listMissionCollections(missionsRootDir);
+    if (collections.length === 0) {
+        note(chalk.yellow('No hay colecciones con misiones guardadas para ejecutar.'), 'Run All');
+        return;
+    }
+
+    let targetCollections = collections;
+    if (selectedCollection && selectedCollection !== '__ALL__') {
+        targetCollections = collections.filter(c => c.value === selectedCollection);
+    }
+
+    if (targetCollections.length === 0) {
+        note(chalk.yellow('La coleccion solicitada no existe o no contiene misiones.'), 'Run All');
+        return;
+    }
+
+    const missionsToRun = [];
+    for (const collection of targetCollections) {
+        const files = listYamlFilesInDir(collection.dir);
+        for (const file of files) {
+            missionsToRun.push({
+                collection,
+                file,
+                fullPath: path.join(collection.dir, file)
+            });
+        }
+    }
+
+    if (missionsToRun.length === 0) {
+        note(chalk.yellow('No se encontraron misiones ejecutables en la seleccion actual.'), 'Run All');
+        return;
+    }
+
+    const sBatch = spinner();
+    if (!debug) {
+        sBatch.start(`Ejecutando ${missionsToRun.length} misiones de ${targetCollections.length} coleccion(es)...`);
+    }
+
+    const summary = [];
+    for (let index = 0; index < missionsToRun.length; index++) {
+        const missionEntry = missionsToRun[index];
+        const rawMission = readYamlFile(missionEntry.fullPath);
+        const missionSpec = normalizeMissionSpec(rawMission, missionEntry.fullPath);
+        const collectionMeta = readCollectionMeta(missionEntry.collection.dir, missionEntry.collection.value);
+        const discoverPath = getMissionStartPath(missionSpec, collectionMeta, '/');
+        const contextDir = process.env.CONTEXT_DIR;
+        const knownLogFiles = new Set(listMissionLogFiles(contextDir));
+
+        if (!missionSpec.prompt) {
+            summary.push({
+                name: missionSpec.name || missionEntry.file,
+                collection: missionEntry.collection.label,
+                success: false,
+                reason: 'missing_prompt'
+            });
+            continue;
+        }
+
+        if (!debug) {
+            sBatch.message(`[${index + 1}/${missionsToRun.length}] ${missionSpec.name} (${missionEntry.collection.label})`);
+        } else {
+            console.log(chalk.cyan(`[RUN-ALL] ${index + 1}/${missionsToRun.length} -> ${missionSpec.name} [${missionEntry.collection.label}]`));
+        }
+
+        try {
+            await run(process.execPath, [
+                path.join(PROJECT_ROOT, 'scripts', 'gen-and-run.mjs'),
+                '--agent',
+                '--batch',
+                '--skip-save-prompt',
+                `--discover=${discoverPath}`,
+                missionSpec.prompt
+            ], {
+                cwd: ORIGINAL_CWD,
+                env: {
+                    ...process.env,
+                    ARCALITY_ROOT: PROJECT_ROOT,
+                    ARCALITY_BATCH_MODE: 'true'
+                }
+            });
+
+            const latestLog = readLatestMissionLog(contextDir, knownLogFiles);
+            const success = latestLog?.data?.success === true;
+            summary.push({
+                name: missionSpec.name || missionEntry.file,
+                collection: missionEntry.collection.label,
+                success,
+                reason: latestLog?.data?.fail_reason || null
+            });
+        } catch (error) {
+            summary.push({
+                name: missionSpec.name || missionEntry.file,
+                collection: missionEntry.collection.label,
+                success: false,
+                reason: error instanceof Error ? error.message : 'runner_error'
+            });
+        }
+    }
+
+    const passed = summary.filter(item => item.success).length;
+    const failed = summary.length - passed;
+
+    if (!debug) {
+        sBatch.stop(chalk.green(`Coleccion ejecutada. Exitosas: ${passed} | Fallidas: ${failed}`));
+    }
+
+    const lines = summary.map(item => {
+        const status = item.success ? 'PASS' : 'FAIL';
+        const reason = item.reason ? ` (${item.reason})` : '';
+        return `- [${status}] ${item.collection} -> ${item.name}${reason}`;
+    });
+    note(lines.join('\n'), 'Resumen Run All');
+}
+
+function showBanner() {
     console.clear();
-    const projectName = 'Arcality';
 
     let version = 'unknown';
     try {
@@ -170,19 +774,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 +797,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";
@@ -438,24 +1045,47 @@ async function main() {
         initialEnv = parseDotEnvFile(path.join(PROJECT_ROOT, '.env'));
     }
 
-    const argv = process.argv.slice(2);
-    let initialDiscoverPath = null;
-    let initialSmartMode = false;
-    let initialAgentMode = false;
-
-    const dIndex = argv.findIndex(a => a === '--discover' || a.startsWith('--discover='));
-    if (dIndex !== -1) {
-        const token = argv[dIndex];
-        if (token.includes('=')) initialDiscoverPath = token.split('=')[1];
-        else if (argv[dIndex + 1]) { initialDiscoverPath = argv[dIndex + 1]; argv.splice(dIndex + 1, 1); }
-        argv.splice(dIndex, 1);
-    }
-    const sIndex = argv.findIndex(a => a === '--smart');
-    if (sIndex !== -1) { initialSmartMode = true; argv.splice(sIndex, 1); }
-    const aIndex = argv.findIndex(a => a === '--agent');
-    if (aIndex !== -1) { initialAgentMode = true; argv.splice(aIndex, 1); }
-    const debugIndex = argv.findIndex(a => a === '--debug');
-    if (debugIndex !== -1) { argv.splice(debugIndex, 1); } // Handled by run() naturally now
+    const argv = process.argv.slice(2);
+    let initialDiscoverPath = null;
+    let initialSmartMode = false;
+    let initialAgentMode = false;
+    let initialRunAllMode = false;
+    let initialTemplateMode = false;
+    let initialSkipSavePrompt = process.env.ARCALITY_SKIP_SAVE_PROMPT === 'true';
+    let initialBatchMode = process.env.ARCALITY_BATCH_MODE === 'true';
+    let initialCollectionPath = null;
+
+    const dIndex = argv.findIndex(a => a === '--discover' || a.startsWith('--discover='));
+    if (dIndex !== -1) {
+        const token = argv[dIndex];
+        if (token.includes('=')) initialDiscoverPath = token.split('=')[1];
+        else if (argv[dIndex + 1]) { initialDiscoverPath = argv[dIndex + 1]; argv.splice(dIndex + 1, 1); }
+        argv.splice(dIndex, 1);
+    }
+    const sIndex = argv.findIndex(a => a === '--smart');
+    if (sIndex !== -1) { initialSmartMode = true; argv.splice(sIndex, 1); }
+    const aIndex = argv.findIndex(a => a === '--agent');
+    if (aIndex !== -1) { initialAgentMode = true; argv.splice(aIndex, 1); }
+    const runAllIndex = argv.findIndex(a => a === '--run-all');
+    if (runAllIndex !== -1) { initialRunAllMode = true; argv.splice(runAllIndex, 1); }
+    const templateIndex = argv.findIndex(a => a === 'template' || a === '--template');
+    if (templateIndex !== -1) { initialTemplateMode = true; argv.splice(templateIndex, 1); }
+    const skipSaveIndex = argv.findIndex(a => a === '--skip-save-prompt');
+    if (skipSaveIndex !== -1) { initialSkipSavePrompt = true; argv.splice(skipSaveIndex, 1); }
+    const batchIndex = argv.findIndex(a => a === '--batch');
+    if (batchIndex !== -1) { initialBatchMode = true; argv.splice(batchIndex, 1); }
+    const collectionIndex = argv.findIndex(a => a === '--collection' || a.startsWith('--collection='));
+    if (collectionIndex !== -1) {
+        const token = argv[collectionIndex];
+        if (token.includes('=')) initialCollectionPath = sanitizeCollectionPath(token.split('=')[1]);
+        else if (argv[collectionIndex + 1]) {
+            initialCollectionPath = sanitizeCollectionPath(argv[collectionIndex + 1]);
+            argv.splice(collectionIndex + 1, 1);
+        }
+        argv.splice(collectionIndex, 1);
+    }
+    const debugIndex = argv.findIndex(a => a === '--debug');
+    if (debugIndex !== -1) { argv.splice(debugIndex, 1); } // Handled by run() naturally now
 
     const promptArg = argv.join(" ").trim();
     let firstRun = true;
@@ -464,59 +1094,116 @@ async function main() {
     setupEnvironment();
 
     while (true) {
-        let prompt = firstRun ? promptArg : "";
-        let agentMode = firstRun ? initialAgentMode : false;
-        let smartMode = firstRun ? initialSmartMode : false;
-        let discoverPath = firstRun ? initialDiscoverPath : null;
-
-        let skipMenu = (firstRun && (prompt || agentMode || smartMode)) || agentMode;
-        if (agentMode) skipMenu = true; // Hard-lock: No menu in agent mode
-
-        firstRun = false;
-
-        if (!skipMenu) {
-            showBanner();
-            try {
+        let prompt = firstRun ? promptArg : "";
+        let agentMode = firstRun ? initialAgentMode : false;
+        let smartMode = firstRun ? initialSmartMode : false;
+        let discoverPath = firstRun ? initialDiscoverPath : null;
+        let runAllMode = firstRun ? initialRunAllMode : false;
+        let templateMode = firstRun ? initialTemplateMode : false;
+        let collectionPath = firstRun ? initialCollectionPath : null;
+        let skipSavePrompt = firstRun ? initialSkipSavePrompt : false;
+        let batchMode = firstRun ? initialBatchMode : false;
+
+        let skipMenu = (firstRun && (prompt || agentMode || smartMode || runAllMode || templateMode)) || agentMode || runAllMode || templateMode;
+        if (agentMode) skipMenu = true; // Hard-lock: No menu in agent mode
+
+        firstRun = false;
+
+        if (!skipMenu) {
+            showBanner();
+            try {
                 // ── Build menu options (single config mode) ──
                 const missionsDir = process.env.MISSIONS_DIR;
-                const savedMissions = fs.existsSync(missionsDir)
-                    ? fs.readdirSync(missionsDir).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'))
-                    : [];
+                const savedMissionCollections = listMissionCollections(missionsDir);
 
                 // Check for YAML files in the yaml output dir from arcality.config
-                let yamlOutputFiles = [];
+                let projectMissionCollections = [];
                 if (projectConfig) {
                     const yamlDir = getYamlOutputDir(projectConfig, ORIGINAL_CWD);
                     if (fs.existsSync(yamlDir)) {
-                        yamlOutputFiles = fs.readdirSync(yamlDir).filter(f => f.endsWith('.yaml') || f.endsWith('.yml'));
+                        projectMissionCollections = listMissionCollections(yamlDir);
                     }
                 }
 
                 // Root-level YAML templates
-                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' }
-                ];
-
-                const action = await select({
-                    message: 'What would you like to do?',
-                    options
-                });
+                const rootMissionFiles = fs.existsSync(ORIGINAL_CWD)
+                    ? fs.readdirSync(ORIGINAL_CWD).filter(f => isYamlFile(f))
+                    : [];
+                const hasSavedMissionSources = savedMissionCollections.length || projectMissionCollections.length || rootMissionFiles.length;
+                const yamlOutputCollections = projectMissionCollections;
+                const rootYamlFiles = rootMissionFiles;
+
+                const options = [
+                    { label: '◉  Desplegar Arcality (Prompt)', value: 'agent' },
+                    ...(savedMissionCollections.length ? [{ label: '▶  Ejecutar colección completa', value: 'run_collection' }] : []),
+                    ...(savedMissionCollections.length ? [{ label: '⟳  Lanzar Misión Archivada (.yaml)', value: 'launch_saved' }] : []),
+                    ...(yamlOutputCollections.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: '📄  Generar templates YAML', value: 'generate_templates' },
+                    { label: '◎  Recalibrar Sistema (init)', value: 'reconfigure' },
+                    { label: '✕  Terminar Proceso', value: 'exit' }
+                ];
+
+                const menuOptions = options
+                    .filter(option => !['launch_saved', 'reuse_yaml', 'yaml_list'].includes(option.value))
+                    .map(option => option.value === 'generate_templates'
+                        ? { ...option, label: '◫  Generar plantillas de misión' }
+                        : option
+                    );
+
+                if (hasSavedMissionSources) {
+                    const insertIndex = Math.min(menuOptions.length, 2);
+                    menuOptions.splice(insertIndex, 0, {
+                        label: '◌  Abrir misión guardada',
+                        value: 'open_saved_mission'
+                    });
+                }
+
+                const action = await select({
+                    message: '¿Qué te gustaría hacer?',
+                    options: menuOptions
+                });
 
                 if (isCancel(action) || action === 'exit') {
-                    outro(chalk.cyan('See you later!'));
+                    outro(chalk.cyan('¡Hasta luego!'));
                     break;
                 }
 
-                if (action === 'agent') {
-                    agentMode = true;
-                } else if (action === 'reconfigure') {
+                if (action === 'agent') {
+                    agentMode = true;
+                } else if (action === 'run_collection') {
+                    runAllMode = true;
+                } else if (action === 'open_saved_mission') {
+                    const projectDir = projectConfig ? getYamlOutputDir(projectConfig, ORIGINAL_CWD) : null;
+                    const selectedMission = await selectSavedMissionSource({
+                        libraryDir: missionsDir,
+                        projectDir,
+                        rootDir: ORIGINAL_CWD
+                    });
+                    if (!selectedMission) continue;
+
+                    const yamlContent = fs.readFileSync(selectedMission.fullPath, 'utf8');
+                    const missionSpec = normalizeMissionSpec(loadYaml(yamlContent), selectedMission.fullPath);
+                    prompt = missionSpec.prompt || yamlContent;
+                    discoverPath = getMissionStartPath(
+                        missionSpec,
+                        readCollectionMeta(path.dirname(selectedMission.fullPath), selectedMission.collection)
+                    );
+                    agentMode = true;
+                } else if (action === 'generate_templates') {
+                    const createdMain = ensureMissionTemplates(missionsDir);
+                    const yamlDir = projectConfig ? getYamlOutputDir(projectConfig, ORIGINAL_CWD) : null;
+                    const createdSecondary = yamlDir ? ensureMissionTemplates(yamlDir) : [];
+                    const createdFiles = [...createdMain, ...createdSecondary];
+                    note(
+                        createdFiles.length > 0
+                            ? chalk.green(`Templates creados:\n${createdFiles.join('\n')}`)
+                            : chalk.cyan(`Los templates ya existen en ${path.join(missionsDir, '_templates')}`),
+                        'Templates Arcality'
+                    );
+                    await waitForEnter('Presiona Enter para volver al menu...');
+                    continue;
+                } else if (action === 'reconfigure') {
                     // Launch arcality init in the user's project directory
                     const initScript = path.join(PROJECT_ROOT, 'scripts', 'init.mjs');
                     try {
@@ -544,61 +1231,113 @@ async function main() {
                         await new Promise(r => setTimeout(r, 3000));
                     }
                     continue;
-                } else if (action === 'launch_saved') {
-                    const sel = await select({
-                        message: 'Choose saved mission:',
-                        options: savedMissions.map(f => ({ label: f, value: f }))
-                    });
-                    if (isCancel(sel)) continue;
-
-                    const yamlContent = fs.readFileSync(path.join(missionsDir, sel), 'utf8');
-                    const data = loadYaml(yamlContent);
-                    prompt = data.prompt || data.mision || yamlContent;
-                    agentMode = true;
-                } else if (action === 'reuse_yaml') {
-                    const yamlDir = getYamlOutputDir(projectConfig, ORIGINAL_CWD);
-                    const sel = await select({
-                        message: 'Choose YAML to reuse:',
-                        options: yamlOutputFiles.map(f => ({ label: f, value: f }))
-                    });
-                    if (isCancel(sel)) continue;
-
-                    const yamlContent = fs.readFileSync(path.join(yamlDir, sel), 'utf8');
-                    const data = loadYaml(yamlContent);
-                    prompt = data.prompt || data.mision || yamlContent;
-                    agentMode = true;
-                } else if (action === 'yaml_list') {
-                    const sel = await select({
-                        message: 'Choose YAML file:',
-                        options: rootYamlFiles.map(f => ({ label: f, value: f }))
+                } else if (action === 'launch_saved') {
+                    const selectedMission = await selectMissionYaml(
+                        missionsDir,
+                        'Elige la carpeta de misiones:',
+                        'Elige la mision guardada:'
+                    );
+                    if (!selectedMission) continue;
+
+                    const yamlContent = fs.readFileSync(selectedMission.fullPath, 'utf8');
+                    const missionSpec = normalizeMissionSpec(loadYaml(yamlContent), selectedMission.fullPath);
+                    prompt = missionSpec.prompt || yamlContent;
+                    discoverPath = getMissionStartPath(missionSpec, readCollectionMeta(path.dirname(selectedMission.fullPath), selectedMission.collection));
+                    agentMode = true;
+                } else if (action === 'reuse_yaml') {
+                    const yamlDir = getYamlOutputDir(projectConfig, ORIGINAL_CWD);
+                    const selectedMission = await selectMissionYaml(
+                        yamlDir,
+                        'Elige la carpeta de YAML:',
+                        'Elige el YAML a reusar:'
+                    );
+                    if (!selectedMission) continue;
+
+                    const yamlContent = fs.readFileSync(selectedMission.fullPath, 'utf8');
+                    const missionSpec = normalizeMissionSpec(loadYaml(yamlContent), selectedMission.fullPath);
+                    prompt = missionSpec.prompt || yamlContent;
+                    discoverPath = getMissionStartPath(missionSpec, readCollectionMeta(path.dirname(selectedMission.fullPath), selectedMission.collection));
+                    agentMode = true;
+                } else if (action === 'yaml_list') {
+                    const sel = await select({
+                        message: 'Elige el archivo YAML:',
+                        options: rootYamlFiles.map(f => ({ label: f, value: f }))
                     });
                     if (isCancel(sel)) continue;
-
-                    const yamlContent = fs.readFileSync(path.join(PROJECT_ROOT, sel), 'utf8');
-                    const data = loadYaml(yamlContent);
-                    prompt = data.mision || data.prompt || yamlContent;
-                    agentMode = true;
-                }
+
+                    const yamlContent = fs.readFileSync(path.join(PROJECT_ROOT, sel), 'utf8');
+                    const missionSpec = normalizeMissionSpec(loadYaml(yamlContent), path.join(PROJECT_ROOT, sel));
+                    prompt = missionSpec.prompt || yamlContent;
+                    discoverPath = getMissionStartPath(missionSpec);
+                    agentMode = true;
+                }
             } catch (e) {
                 console.error("Menu error:", e);
                 break;
-            }
-        }
-
-        // --- VALIDATION AND CAPTURE OF PARAMETERS FOR THE AGENT ---
-        if (agentMode) {
+            }
+        }
+
+        if (templateMode) {
+            const createdMain = ensureMissionTemplates(process.env.MISSIONS_DIR);
+            const yamlDir = projectConfig ? getYamlOutputDir(projectConfig, ORIGINAL_CWD) : null;
+            const createdSecondary = yamlDir ? ensureMissionTemplates(yamlDir) : [];
+            const createdFiles = [...createdMain, ...createdSecondary];
+            note(
+                createdFiles.length > 0
+                    ? chalk.green(`Templates creados:\n${createdFiles.join('\n')}`)
+                    : chalk.cyan(`Los templates ya existen en ${path.join(process.env.MISSIONS_DIR, '_templates')}`),
+                'Templates Arcality'
+            );
+
+            if (skipMenu) return;
+            continue;
+        }
+
+        if (runAllMode) {
+            let batchCollection = collectionPath;
+            if (!batchCollection && process.stdin.isTTY) {
+                const availableCollections = listMissionCollections(process.env.MISSIONS_DIR);
+                const selectedBatchCollection = await select({
+                    message: 'Elige la colección a ejecutar:',
+                    options: [
+                        { label: `Todas las colecciones (${availableCollections.length})`, value: '__ALL__' },
+                        ...availableCollections.map(collection => ({
+                            label: `${collection.label} (${collection.count})${collection.description ? ` - ${collection.description}` : ''}`,
+                            value: collection.value
+                        }))
+                    ]
+                });
+                if (isCancel(selectedBatchCollection)) {
+                    if (skipMenu) return;
+                    continue;
+                }
+                batchCollection = selectedBatchCollection;
+            }
+
+            await runCollectionBatch({
+                missionsRootDir: process.env.MISSIONS_DIR,
+                selectedCollection: batchCollection || '__ALL__',
+                debug: process.argv.includes('--debug')
+            });
+
+            if (skipMenu) return;
+            continue;
+        }
+
+        // --- VALIDATION AND CAPTURE OF PARAMETERS FOR THE AGENT ---
+        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 +1350,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 +1392,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 +1405,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 +1436,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 +1466,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 +1489,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 +1502,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 +1560,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 +1581,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 +1589,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 +1697,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,42 +1757,72 @@ 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?',
-                    options: [
-                        { label: '✅ Yes, save as YAML', value: 'yes' },
-                        { label: '❌ No, thanks', value: 'no' }
-                    ]
-                });
-
-                if (saveDecision === 'yes') {
+                // ── Save Mission YAML ──
+                let saveDecision = 'no';
+                if (!skipSavePrompt && !batchMode) {
+                    saveDecision = await select({
+                        message: '¿Quieres guardar esta misión para ejecutarla de nuevo más tarde?',
+                        options: [
+                            { 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)) {
-                        const safeName = name.trim().replace(/[^a-z0-9]/gi, '_').toLowerCase();
+                    if (!isCancel(name)) {
+                        const safeName = name.trim().replace(/[^a-z0-9]/gi, '_').toLowerCase();
 
                         // Save to missions dir (existing flow)
                         const missionsDir = process.env.MISSIONS_DIR;
-                        const yamlPathMissions = path.join(missionsDir, `${safeName}.yaml`);
-
-                        const safeProjectName = projectConfig?.project?.name || 'Default';
-                        let yamlData = `name: ${JSON.stringify(name)}\nprompt: ${JSON.stringify(prompt)}\nproject: ${JSON.stringify(safeProjectName)}\ncreated_at: ${JSON.stringify(new Date().toISOString())}\n`;
+                        const missionSaveDir = await selectMissionSaveDir(missionsDir);
+                        if (!missionSaveDir) {
+                            note(chalk.yellow('Guardado de mision cancelado.'), 'Persistencia Arcality');
+                            continue;
+                        }
+                        const yamlPathMissions = path.join(missionSaveDir.targetDir, `${safeName}.yaml`);
+
+                        const safeProjectName = projectConfig?.project?.name || 'Default';
+                        const collectionValue = missionSaveDir.relDir ? toPosixPath(missionSaveDir.relDir) : '';
+                        const suiteValue = missionSaveDir.relDir ? toPosixPath(missionSaveDir.relDir).split('/')[0] : '';
+                        let yamlData = [
+                            `name: ${JSON.stringify(name)}`,
+                            `prompt: ${JSON.stringify(prompt)}`,
+                            `project: ${JSON.stringify(safeProjectName)}`,
+                            ...(collectionValue ? [`collection: ${JSON.stringify(collectionValue)}`] : []),
+                            ...(suiteValue ? [`suite: ${JSON.stringify(suiteValue)}`] : []),
+                            'tags: []',
+                            `priority: ${JSON.stringify('normal')}`,
+                            `created_at: ${JSON.stringify(new Date().toISOString())}`
+                        ].join('\n') + '\n';
 
                         const smartYamlPath = path.join(process.env.CONTEXT_DIR, 'last-mission-smart.yaml');
-                        if (fs.existsSync(smartYamlPath)) {
-                            yamlData = fs.readFileSync(smartYamlPath, 'utf8');
-                        }
+                        if (fs.existsSync(smartYamlPath)) {
+                            const smartYamlContent = fs.readFileSync(smartYamlPath, 'utf8').trim();
+                            yamlData = [
+                                `name: ${JSON.stringify(name)}`,
+                                `prompt: ${JSON.stringify(prompt)}`,
+                                `project: ${JSON.stringify(safeProjectName)}`,
+                                ...(collectionValue ? [`collection: ${JSON.stringify(collectionValue)}`] : []),
+                                ...(suiteValue ? [`suite: ${JSON.stringify(suiteValue)}`] : []),
+                                'tags: []',
+                                `priority: ${JSON.stringify('normal')}`,
+                                `created_at: ${JSON.stringify(new Date().toISOString())}`,
+                                smartYamlContent
+                            ].join('\n') + '\n';
+                        }
 
                         // Internal fallback backup for the agent
                         fs.writeFileSync(yamlPathMissions, yamlData);
@@ -1048,11 +1830,13 @@ async function main() {
                         // Primary save to user's specified directory from arcality.config
                         if (projectConfig) {
                             const yamlOutputDir = ensureYamlOutputDir(projectConfig, ORIGINAL_CWD);
-                            const yamlPathOutput = path.join(yamlOutputDir, `${safeName}.yaml`);
+                            const yamlOutputTargetDir = missionSaveDir.relDir ? path.join(yamlOutputDir, missionSaveDir.relDir) : yamlOutputDir;
+                            fs.mkdirSync(yamlOutputTargetDir, { recursive: true });
+                            const yamlPathOutput = path.join(yamlOutputTargetDir, `${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 +1845,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 +1865,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 +1874,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(() => { });
@@ -1106,8 +1890,11 @@ async function main() {
                 try {
                     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 files = fs.readdirSync(ctxDir);
+                        const logFiles = files.filter(f =>
+                            (f.startsWith('arcality-log-') || f.startsWith('agent-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 +1921,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 +1935,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ó ──
@@ -1178,16 +1965,16 @@ async function main() {
                     globalReportProcess = null;
                 }
 
-                if (fs.existsSync(arcalityPath)) {
-                    console.log(chalk.blue(`🌐 Opening Arcality Report: ${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).`));
-                }
+                if (!batchMode && fs.existsSync(arcalityPath)) {
+                    console.log(chalk.blue(`🌐 Abriendo Reporte de Arcality: ${arcalityPath}`));
+                    if (process.platform === "win32") {
+                        exec(`start "" "${arcalityPath}"`);
+                    } else {
+                        exec(`open "${arcalityPath}"`);
+                    }
+                } else if (!fs.existsSync(arcalityPath)) {
+                    console.log(chalk.yellow(`⚠️  Reporte no generado (la prueba pudo haber fallado antes de completarse).`));
+                }
 
                 await new Promise(resolve => setTimeout(resolve, 2000));
 
@@ -1197,52 +1984,61 @@ async function main() {
                     process.env.ARCALITY_API_KEY
                 );
 
-                // 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...'));
-                await new Promise(resolve => {
-                    const onKey = (key) => {
-                        const keyStr = String(key);
-                        if (keyStr.includes('\r') || keyStr.includes('\n') || keyStr === '\u0003') {
-                            process.stdin.off('data', onKey);
-
-                            // Restaurar stdin en modo normal para @clack/prompts
-                            if (process.stdin.isTTY && process.stdin.setRawMode) {
-                                process.stdin.setRawMode(false);
-                            }
-                            process.stdin.pause();
+                // 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);
 
-                            if (keyStr === '\u0003') process.emit('SIGINT'); // Ctrl+C = salir
-                            else resolve();
-                        }
-                    };
-
-                    // ── BUGFIX: @clack/prompts llama explícitamente a process.stdin.pause()
-                    // al terminar cada select()/text(). En Node.js, agregar un listener 'data'
-                    // a un stream EXPLÍCITAMENTE pausado NO lo reactiva automáticamente.
-                    // Resultado: el event loop queda vacío y el proceso termina antes de que
-                    // el usuario pueda presionar Enter.
-                    // Solución: llamar resume() explícitamente antes de registrar el listener.
-                    if (process.stdin.isTTY && process.stdin.setRawMode) {
-                        process.stdin.setRawMode(true); // raw mode para capturar Enter inmediatamente
-                    }
-                    process.stdin.resume(); // ← CRÍTICO: reactiva stdin para mantener el event loop vivo
-                    process.stdin.on('data', onKey);
-                });
+                if (!batchMode) {
+                    // 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   Presiona Enter para regresar al menú...'));
+                    await new Promise(resolve => {
+                        const onKey = (key) => {
+                            const keyStr = String(key);
+                            if (keyStr.includes('\r') || keyStr.includes('\n') || keyStr === '\u0003') {
+                                process.stdin.off('data', onKey);
+
+                                // Restaurar stdin en modo normal para @clack/prompts
+                                if (process.stdin.isTTY && process.stdin.setRawMode) {
+                                    process.stdin.setRawMode(false);
+                                }
+                                // 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.exit(0); // Ctrl+C = salir inmediatamente
+                                } else {
+                                    resolve();
+                                }
+                            }
+                        };
+
+                        // ── BUGFIX: @clack/prompts llama explícitamente a process.stdin.pause()
+                        // al terminar cada select()/text(). En Node.js, agregar un listener 'data'
+                        // a un stream EXPLÍCITAMENTE pausado NO lo reactiva automáticamente.
+                        // Resultado: el event loop queda vacío y el proceso termina antes de que
+                        // el usuario pueda presionar Enter.
+                        // Solución: llamar resume() explícitamente antes de registrar el listener.
+                        if (process.stdin.isTTY && process.stdin.setRawMode) {
+                            process.stdin.setRawMode(true); // raw mode para capturar Enter inmediatamente
+                        }
+                        process.stdin.resume(); // ← CRÍTICO: reactiva stdin para mantener el event loop vivo
+                        process.stdin.on('data', onKey);
+                    });
+                }
 
                 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;