@arcadialdev/arcality 3.0.0 → 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,10 +159,613 @@ 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();
 
     let version = 'unknown';
@@ -440,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;
@@ -466,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: '◉  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({
+                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
-                });
+                    options: menuOptions
+                });
 
                 if (isCancel(action) || action === 'exit') {
                     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 {
@@ -546,49 +1231,101 @@ async function main() {
                         await new Promise(r => setTimeout(r, 3000));
                     }
                     continue;
-                } else if (action === 'launch_saved') {
-                    const sel = await select({
-                        message: 'Elige la misión guardada:',
-                        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: 'Elige el YAML a reusar:',
-                        options: yamlOutputFiles.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(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: '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('🤖 Misión para Arcality (Requerida):'),
@@ -1026,36 +1763,66 @@ async function main() {
                 // ── Ping Project ──
                 await pingProject(finalProjectId, process.env.ARCALITY_API_KEY);
 
-                // ── Save Mission YAML ──
-                const 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') {
+                // ── 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: 'Nombre de la misión (ej., login_valido):',
                         placeholder: 'my_mission',
                         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);
@@ -1063,7 +1830,9 @@ 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(`✅ Misión guardada en: ${yamlPathOutput}`), 'Persistencia Arcality');
                         } else {
@@ -1121,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('arcality-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'));
@@ -1193,16 +1965,16 @@ async function main() {
                     globalReportProcess = null;
                 }
 
-                if (fs.existsSync(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(`⚠️  Reporte no generado (la prueba pudo haber fallado antes de completarse).`));
-                }
+                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));
 
@@ -1216,46 +1988,48 @@ async function main() {
                 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   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 (!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('¡Misión terminada! Hasta luego.'));