@arcadialdev/arcality 3.0.2 → 3.0.3

package/scripts/gen-and-run.mjs

@@ -1,139 +1,153 @@
-#!/usr/bin/env node
-// scripts/gen-and-run.mjs
-// Main Arcality CLI loop — v3 Single Configuration Mode
-// Reads from arcality.config instead of multi-config .env approach.
-
-import 'dotenv/config';
-import fs from "node:fs";
-import path from "node:path";
-import { createRequire } from 'node:module';
-import { spawn, exec } from "node:child_process";
-import chalk from "chalk";
-import { fileURLToPath, pathToFileURL } from 'url';
-const require = createRequire(import.meta.url);
-import figlet from "figlet";
-import { intro, outro, select, text, spinner, note, isCancel, cancel } from '@clack/prompts';
-import { load as loadYaml } from 'js-yaml';
-import { loadGlobalConfig, getApiKey, getApiUrl, maskApiKey, setupProcessEnv } from '../src/configLoader.mjs';
-import {
-    configExists,
-    loadProjectConfig,
-    validateConfig,
-    injectConfigToEnv,
-    getYamlOutputDir,
-    ensureYamlOutputDir,
-} from '../src/configManager.mjs';
-
-// Load global config at startup (injects keys into process.env)
-setupProcessEnv();
-
-// ── WINDOWS FIX: Interceptar Ctrl+C antes que cmd.exe ──
-// En Windows, `arcality` se ejecuta vía arcality.cmd (creado por npm para el campo bin).
-// cmd.exe intercepta Ctrl+C y muestra "¿Desea terminar el trabajo por lotes (S/N)?".
-// Al presionar S, mata el árbol de procesos antes de que nuestro finally pueda correr.
-//
-// La solución: setRawMode(true) hace que Node capture los bytes del teclado directamente,
-// ANTES de que cmd.exe los procese. Al detectar Ctrl+C (byte 0x03) lo convertimos en
-// un SIGINT de Node — cmd.exe nunca lo ve y nunca muestra el prompt.
-if (process.stdin.isTTY && process.stdin.setRawMode) {
-    try {
-        process.stdin.setRawMode(true);
-        process.stdin.resume();
-        process.stdin.setEncoding('utf8');
-        process.stdin.on('data', (key) => {
-            if (key === '\u0003') { // Ctrl+C
-                process.emit('SIGINT');
-            }
-        });
-    } catch (e) {
-        // Si falla (ej. en CI sin TTY), continuar sin raw mode
-    }
-}
-
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
-const PROJECT_ROOT = process.env.ARCALITY_ROOT || path.join(__dirname, "..");
-
-const ORIGINAL_CWD = process.cwd();
-
-// ── Load arcality.config if present ──
-let projectConfig = loadProjectConfig(ORIGINAL_CWD) || loadProjectConfig(PROJECT_ROOT);
-if (projectConfig) {
-    injectConfigToEnv(projectConfig);
-}
-
-function parseDotEnvFile(p) {
-    try {
-        const raw = fs.readFileSync(p, 'utf8');
-        const lines = raw.split(/\r?\n/);
-        const out = {};
-        for (const line of lines) {
-            const trimmed = line.trim();
-            if (!trimmed || trimmed.startsWith('#')) continue;
-            const idx = trimmed.indexOf('=');
-            if (idx === -1) continue;
-            let k = trimmed.slice(0, idx).trim();
-            let v = trimmed.slice(idx + 1).trim();
-            if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) v = v.slice(1, -1);
-            out[k] = v;
-        }
-        return out;
-    } catch {
-        return {};
-    }
-}
-
-function updateDotEnvFile(updates) {
-    const p = path.join(PROJECT_ROOT, '.env');
-    let content = '';
-    try {
-        content = fs.readFileSync(p, 'utf8');
-    } catch {
-        content = '';
-    }
-
-    let lines = content.split(/\r?\n/);
-    const keys = Object.keys(updates);
-    const updatedKeys = new Set();
-
-    lines = lines.map(line => {
-        const trimmed = line.trim();
-        if (!trimmed || trimmed.startsWith('#')) return line;
-        const idx = trimmed.indexOf('=');
-        if (idx === -1) return line;
-        const k = trimmed.slice(0, idx).trim();
-        if (keys.includes(k)) {
-            updatedKeys.add(k);
-            return `${k}=${updates[k]}`;
-        }
-        return line;
-    });
-
-    keys.forEach(k => {
-        if (!updatedKeys.has(k)) {
-            lines.push(`${k}=${updates[k]}`);
-        }
-    });
-
-    fs.writeFileSync(p, lines.join('\n'), 'utf8');
-    keys.forEach(k => { process.env[k] = updates[k]; });
-}
-
+#!/usr/bin/env node
+// scripts/gen-and-run.mjs
+// Main Arcality CLI loop — v3 Single Configuration Mode
+// Reads from arcality.config instead of multi-config .env approach.
+
+import 'dotenv/config';
+import fs from "node:fs";
+import path from "node:path";
+import { createRequire } from 'node:module';
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import chalk from "chalk";
+import { fileURLToPath, pathToFileURL } from 'url';
+const require = createRequire(import.meta.url);
+import figlet from "figlet";
+import { intro, outro, select, text, spinner, note, isCancel, cancel } from '@clack/prompts';
+import { load as loadYaml } from 'js-yaml';
+import { loadGlobalConfig, getApiKey, getApiUrl, maskApiKey, setupProcessEnv } from '../src/configLoader.mjs';
+import {
+    configExists,
+    loadProjectConfig,
+    validateConfig,
+    injectConfigToEnv,
+    getYamlOutputDir,
+    ensureYamlOutputDir,
+    isRealProjectId,
+} from '../src/configManager.mjs';
+
+// Load global config at startup (injects keys into process.env)
+setupProcessEnv();
+
+// ── WINDOWS FIX: Interceptar Ctrl+C antes que cmd.exe ──
+// En Windows, `arcality` se ejecuta vía arcality.cmd (creado por npm para el campo bin).
+// cmd.exe intercepta Ctrl+C y muestra "¿Desea terminar el trabajo por lotes (S/N)?".
+// Al presionar S, mata el árbol de procesos antes de que nuestro finally pueda correr.
+//
+// La solución: setRawMode(true) hace que Node capture los bytes del teclado directamente,
+// ANTES de que cmd.exe los procese. Al detectar Ctrl+C (byte 0x03) lo convertimos en
+// un SIGINT de Node — cmd.exe nunca lo ve y nunca muestra el prompt.
+if (process.stdin.isTTY && process.stdin.setRawMode) {
+    try {
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding('utf8');
+        process.stdin.on('data', (key) => {
+            if (key === '\u0003') { // Ctrl+C
+                process.emit('SIGINT');
+            }
+        });
+    } catch (e) {
+        // Si falla (ej. en CI sin TTY), continuar sin raw mode
+    }
+}
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+const PROJECT_ROOT = process.env.ARCALITY_ROOT || path.join(__dirname, "..");
+const RUNNER_SOURCE_FILE = path.join(PROJECT_ROOT, 'tests', '_helpers', 'agentic-runner.spec.ts');
+const RUNNER_BUNDLE_FILE = path.join(PROJECT_ROOT, 'tests', '_helpers', 'agentic-runner.bundle.spec.js');
+
+const ORIGINAL_CWD = process.cwd();
+const COLLECTION_DEFAULT_CONCURRENCY = 3;
+const COLLECTION_MAX_CONCURRENCY = 5;
+
+// ── Load arcality.config if present ──
+let projectConfig = loadProjectConfig(ORIGINAL_CWD) || loadProjectConfig(PROJECT_ROOT);
+if (projectConfig) {
+    if (!isRealProjectId(projectConfig.projectId)) {
+        console.error(chalk.red('\n[FATAL] Proyecto Arcality no conectado.'));
+        console.error(chalk.yellow('El arcality.config actual no tiene un Project ID real del backend.'));
+        console.error(chalk.gray('Ejecuta `arcality init` para registrar el proyecto en Arcality antes de correr misiones.\n'));
+        process.exit(1);
+    }
+    injectConfigToEnv(projectConfig);
+}
+
+function parseDotEnvFile(p) {
+    try {
+        const raw = fs.readFileSync(p, 'utf8');
+        const lines = raw.split(/\r?\n/);
+        const out = {};
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed || trimmed.startsWith('#')) continue;
+            const idx = trimmed.indexOf('=');
+            if (idx === -1) continue;
+            let k = trimmed.slice(0, idx).trim();
+            let v = trimmed.slice(idx + 1).trim();
+            if ((v.startsWith('"') && v.endsWith('"')) || (v.startsWith("'") && v.endsWith("'"))) v = v.slice(1, -1);
+            out[k] = v;
+        }
+        return out;
+    } catch {
+        return {};
+    }
+}
+
+function updateDotEnvFile(updates) {
+    const p = path.join(PROJECT_ROOT, '.env');
+    let content = '';
+    try {
+        content = fs.readFileSync(p, 'utf8');
+    } catch {
+        content = '';
+    }
+
+    let lines = content.split(/\r?\n/);
+    const keys = Object.keys(updates);
+    const updatedKeys = new Set();
+
+    lines = lines.map(line => {
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#')) return line;
+        const idx = trimmed.indexOf('=');
+        if (idx === -1) return line;
+        const k = trimmed.slice(0, idx).trim();
+        if (keys.includes(k)) {
+            updatedKeys.add(k);
+            return `${k}=${updates[k]}`;
+        }
+        return line;
+    });
+
+    keys.forEach(k => {
+        if (!updatedKeys.has(k)) {
+            lines.push(`${k}=${updates[k]}`);
+        }
+    });
+
+    fs.writeFileSync(p, lines.join('\n'), 'utf8');
+    keys.forEach(k => { process.env[k] = updates[k]; });
+}
+
 function setupEnvironment() {
-
-    // Use config name from arcality.config or fallback
-    const configName = projectConfig?.project?.name || 'Default';
-    const baseUrl = projectConfig?.project?.baseUrl || process.env.BASE_URL || 'http://localhost';
-
-    const rootOutDir = path.join(ORIGINAL_CWD, '.arcality', 'out');
-    const configDir = path.join(rootOutDir, configName.replace(/[^a-zA-Z0-9_-]/g, '_'));
-
-    process.env.DOMAIN_DIR = configDir;
-    process.env.MISSIONS_DIR = path.join(configDir, 'missions');
-    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 => {
+
+    // Use config name from arcality.config or fallback
+    const configName = projectConfig?.project?.name || 'Default';
+    const baseUrl = projectConfig?.project?.baseUrl || process.env.BASE_URL || 'http://localhost';
+
+    const rootOutDir = path.join(ORIGINAL_CWD, '.arcality', 'out');
+    const configDir = path.join(rootOutDir, configName.replace(/[^a-zA-Z0-9_-]/g, '_'));
+
+    const runDomainDir = process.env.ARCALITY_RUN_DOMAIN_DIR || configDir;
+    process.env.DOMAIN_DIR = runDomainDir;
+    process.env.MISSIONS_DIR = process.env.ARCALITY_RUN_MISSIONS_DIR || path.join(configDir, 'missions');
+    process.env.CONTEXT_DIR = process.env.ARCALITY_RUN_CONTEXT_DIR || path.join(runDomainDir, 'context');
+    process.env.REPORTS_DIR = process.env.ARCALITY_RUN_REPORTS_DIR || path.join(runDomainDir, 'reports');
+    process.env.PLAYWRIGHT_OUTPUT_DIR = process.env.ARCALITY_RUN_PLAYWRIGHT_OUTPUT_DIR || path.join(runDomainDir, 'playwright-output');
+
+    [process.env.MISSIONS_DIR, process.env.CONTEXT_DIR, process.env.REPORTS_DIR, process.env.PLAYWRIGHT_OUTPUT_DIR].forEach(dir => {
         if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
     });
     ensureMissionTemplates(process.env.MISSIONS_DIR);
@@ -143,22 +157,22 @@ function setupEnvironment() {
         const yamlOutputDir = ensureYamlOutputDir(projectConfig, ORIGINAL_CWD);
         ensureMissionTemplates(yamlOutputDir);
     }
-
-    // Framework detection from package.json (NO .git)
-    let techStack = 'Not detected';
-    try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(PROJECT_ROOT, 'package.json'), 'utf8'));
-        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
-        if (deps['next']) techStack = 'Next.js 🚀';
-        else if (deps['vite']) techStack = 'Vite ⚡';
-        else if (deps['react-scripts']) techStack = 'Create React App ⚛️';
-    } catch { }
-
-    // Override with arcality.config detection if available
-    if (projectConfig?.project?.frameworkDetected) {
-        techStack = projectConfig.project.frameworkDetected;
-    }
-
+
+    // Framework detection from package.json (NO .git)
+    let techStack = 'Not detected';
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(PROJECT_ROOT, 'package.json'), 'utf8'));
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        if (deps['next']) techStack = 'Next.js 🚀';
+        else if (deps['vite']) techStack = 'Vite ⚡';
+        else if (deps['react-scripts']) techStack = 'Create React App ⚛️';
+    } catch { }
+
+    // Override with arcality.config detection if available
+    if (projectConfig?.project?.frameworkDetected) {
+        techStack = projectConfig.project.frameworkDetected;
+    }
+
     return { configName, baseUrl, techStack, configDir };
 }
 
@@ -585,33 +599,42 @@ default_page_path: "/welcome"
     return created;
 }
 
-async function waitForEnter(message = 'Presiona Enter para continuar...') {
+async function waitForEnter(message = 'Presiona Enter para continuar...', options = {}) {
     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);
+        const restoreRawMode = options.restoreRawMode !== false;
+        const pauseOnResolve = options.pauseOnResolve === true;
+        if (process.stdin.isTTY && process.stdin.setRawMode) {
+            process.stdin.setRawMode(false);
+        }
 
-                if (process.stdin.isTTY && process.stdin.setRawMode) {
-                    process.stdin.setRawMode(false);
-                }
+        const rl = createInterface({
+            input: process.stdin,
+            output: process.stdout
+        });
 
-                if (keyStr === '\u0003') {
-                    process.exit(0);
-                } else {
-                    resolve();
-                }
+        const cleanup = () => {
+            rl.close();
+            if (process.stdin.isTTY && process.stdin.setRawMode && restoreRawMode) {
+                process.stdin.setRawMode(true);
+                process.stdin.resume();
+            }
+            if (pauseOnResolve) {
+                process.stdin.pause();
             }
         };
 
-        if (process.stdin.isTTY && process.stdin.setRawMode) {
-            process.stdin.setRawMode(true);
-        }
-        process.stdin.resume();
-        process.stdin.on('data', onKey);
+        rl.on('SIGINT', () => {
+            cleanup();
+            process.exit(0);
+        });
+
+        rl.question('', () => {
+            cleanup();
+            resolve();
+        });
     });
 }
 
@@ -646,15 +669,320 @@ function readLatestMissionLog(contextDir, knownFiles = new Set()) {
     }
 }
 
+function readMissionResult(runDomainDir, contextDir, knownFiles = new Set()) {
+    const persistedResultPath = runDomainDir
+        ? path.join(runDomainDir, 'mission-result.json')
+        : null;
+
+    if (persistedResultPath && fs.existsSync(persistedResultPath)) {
+        try {
+            return {
+                file: persistedResultPath,
+                data: JSON.parse(fs.readFileSync(persistedResultPath, 'utf8'))
+            };
+        } catch {
+            // Fallback below.
+        }
+    }
+
+    return readLatestMissionLog(contextDir, knownFiles);
+}
+
+function normalizeCollectionConcurrency(value, fallback = COLLECTION_DEFAULT_CONCURRENCY) {
+    const n = Number(value);
+    if (!Number.isFinite(n) || n < 1) return fallback;
+    return Math.min(COLLECTION_MAX_CONCURRENCY, Math.max(1, Math.floor(n)));
+}
+
+function createCollectionRunId() {
+    return new Date().toISOString()
+        .replace(/\.\d{3}Z$/, 'Z')
+        .replace(/[^0-9TZ]/g, '')
+        .replace('T', '-')
+        .replace('Z', '');
+}
+
+function formatPathForHtml(value) {
+    return String(value || '').split(path.sep).join('/');
+}
+
+function escapeHtml(value) {
+    return String(value ?? '')
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+}
+
+function createUniqueMissionSlug(missionSpec, fileName, index, usedSlugs) {
+    const baseName = missionSpec.name || fileName || `mission-${index + 1}`;
+    const base = sanitizePathSegment(baseName) || `mission_${index + 1}`;
+    const prefix = String(index + 1).padStart(2, '0');
+    let candidate = `${prefix}-${base}`;
+    let suffix = 2;
+
+    while (usedSlugs.has(candidate)) {
+        candidate = `${prefix}-${base}-${suffix}`;
+        suffix += 1;
+    }
+
+    usedSlugs.add(candidate);
+    return candidate;
+}
+
+async function ensureRunnerBundle({ debug = false, spinnerRef = null, statusMessage = 'Compilando Arcality Runner...' } = {}) {
+    const sourceExists = fs.existsSync(RUNNER_SOURCE_FILE);
+    const bundleExists = fs.existsSync(RUNNER_BUNDLE_FILE);
+
+    if (!sourceExists) {
+        if (bundleExists) {
+            if (debug) {
+                console.log(chalk.gray('[DEBUG] Runner fuente no incluido en el paquete; usando bundle precompilado.'));
+            }
+            return true;
+        }
+
+        console.warn(chalk.yellow('\nAdvertencia: No se encontro el runner fuente ni el bundle precompilado.'));
+        return false;
+    }
+
+    try {
+        if (spinnerRef && !debug) {
+            spinnerRef.message(statusMessage);
+        } else if (debug) {
+            console.log(chalk.cyan(statusMessage));
+        }
+
+        await runNpmScript(['run', 'build:runner'], {
+            cwd: PROJECT_ROOT,
+            streamOutput: debug
+        });
+        return true;
+    } catch (err) {
+        console.warn(chalk.yellow(`\nAdvertencia: No se pudo compilar el runner: ${err.message}`));
+        return false;
+    }
+}
+
+async function buildRunnerForCollection(debug = false, spinnerRef = null) {
+    return ensureRunnerBundle({
+        debug,
+        spinnerRef,
+        statusMessage: debug
+            ? '[RUN-ALL] Compilando Arcality Runner una sola vez para la coleccion...'
+            : 'Compilando Arcality Runner una sola vez para la coleccion...'
+    });
+}
+
+async function runWithConcurrency(items, concurrency, worker) {
+    const results = new Array(items.length);
+    let nextIndex = 0;
+    const workerCount = Math.min(Math.max(1, concurrency), items.length);
+
+    await Promise.all(Array.from({ length: workerCount }, async () => {
+        while (nextIndex < items.length) {
+            const currentIndex = nextIndex;
+            nextIndex += 1;
+            results[currentIndex] = await worker(items[currentIndex], currentIndex);
+        }
+    }));
+
+    return results;
+}
+
+function writeCollectionArtifacts(runDir, summary, metadata) {
+    const summaryPath = path.join(runDir, 'summary.json');
+    const reportDir = path.join(runDir, 'collection-report');
+    const reportPath = path.join(reportDir, 'index.html');
+
+    if (!fs.existsSync(reportDir)) fs.mkdirSync(reportDir, { recursive: true });
+
+    const passed = summary.filter(item => item.success).length;
+    const failed = summary.length - passed;
+    const startedAt = metadata.startedAt || new Date().toISOString();
+    const finishedAt = new Date().toISOString();
+    const durationMs = summary.reduce((total, item) => total + (item.durationMs || 0), 0);
+
+    fs.writeFileSync(summaryPath, JSON.stringify({
+        runId: metadata.runId,
+        collection: metadata.collectionLabel,
+        concurrency: metadata.concurrency,
+        startedAt,
+        finishedAt,
+        total: summary.length,
+        passed,
+        failed,
+        missions: summary
+    }, null, 2));
+
+    const rows = summary.map(item => {
+        const reportExists = item.reportPath && fs.existsSync(item.reportPath);
+        const relativeReport = reportExists
+            ? formatPathForHtml(path.relative(reportDir, item.reportPath))
+            : '';
+        const status = item.success ? 'Exitosa' : 'Error';
+        const tone = item.success ? 'passed' : 'failed';
+        const reportLink = reportExists
+            ? `<a href="${escapeHtml(relativeReport)}">Abrir reporte</a>`
+            : '<span class="muted">Sin reporte</span>';
+        const reason = item.reason ? escapeHtml(item.reason) : '<span class="muted">-</span>';
+
+        return `
+            <tr>
+                <td><span class="status ${tone}">${status}</span></td>
+                <td>
+                    <strong>${escapeHtml(item.name)}</strong>
+                    <small>${escapeHtml(item.collection || 'General')}</small>
+                </td>
+                <td>${reason}</td>
+                <td>${item.durationMs ? Math.round(item.durationMs / 1000) + 's' : '-'}</td>
+                <td>${reportLink}</td>
+            </tr>
+        `;
+    }).join('');
+
+    const html = `<!DOCTYPE html>
+<html lang="es">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Arcality Collection Report</title>
+    <style>
+        :root {
+            --bg: #07080d;
+            --surface: #10131b;
+            --line: #293042;
+            --text: #f7f4ff;
+            --muted: #a9afc0;
+            --ok: #36d399;
+            --bad: #ff5d7a;
+            --accent: #75c7ff;
+        }
+        * { box-sizing: border-box; }
+        body {
+            margin: 0;
+            min-height: 100vh;
+            background: var(--bg);
+            color: var(--text);
+            font-family: Inter, ui-sans-serif, system-ui, -apple-system, BlinkMacSystemFont, "Segoe UI", sans-serif;
+        }
+        main { width: min(1180px, calc(100% - 48px)); margin: 0 auto; padding: 44px 0 64px; }
+        header { display: flex; justify-content: space-between; gap: 24px; align-items: flex-start; margin-bottom: 34px; }
+        h1 { margin: 0 0 10px; font-size: clamp(38px, 6vw, 72px); line-height: .95; letter-spacing: 0; }
+        p { margin: 0; color: var(--muted); font-size: 16px; }
+        .badge { border: 1px solid var(--line); border-radius: 8px; padding: 16px 18px; min-width: 250px; background: rgba(255,255,255,.02); }
+        .badge small { color: var(--muted); display: block; text-transform: uppercase; font-size: 11px; letter-spacing: .14em; margin-bottom: 8px; }
+        .badge strong { display: block; font-size: 22px; }
+        .grid { display: grid; grid-template-columns: repeat(4, minmax(0, 1fr)); border: 1px solid var(--line); border-radius: 8px; overflow: hidden; margin-bottom: 28px; }
+        .metric { padding: 20px; background: var(--surface); border-right: 1px solid var(--line); }
+        .metric:last-child { border-right: 0; }
+        .metric b { display: block; font-size: 30px; margin-bottom: 8px; }
+        .metric span { color: var(--muted); text-transform: uppercase; font-size: 11px; letter-spacing: .14em; font-weight: 700; }
+        table { width: 100%; border-collapse: collapse; background: var(--surface); border: 1px solid var(--line); border-radius: 8px; overflow: hidden; }
+        th, td { text-align: left; padding: 16px; border-bottom: 1px solid var(--line); vertical-align: top; }
+        th { color: var(--muted); text-transform: uppercase; font-size: 11px; letter-spacing: .14em; }
+        tr:last-child td { border-bottom: 0; }
+        td small { display: block; color: var(--muted); margin-top: 4px; }
+        a { color: var(--accent); text-decoration: none; font-weight: 700; }
+        .status { display: inline-flex; border-radius: 999px; padding: 5px 9px; font-size: 11px; font-weight: 800; text-transform: uppercase; letter-spacing: .08em; }
+        .status.passed { color: var(--ok); background: rgba(54, 211, 153, .12); }
+        .status.failed { color: var(--bad); background: rgba(255, 93, 122, .12); }
+        .muted { color: var(--muted); }
+        @media (max-width: 760px) {
+            main { width: min(100% - 28px, 1180px); padding-top: 28px; }
+            header { display: block; }
+            .badge { margin-top: 22px; }
+            .grid { grid-template-columns: repeat(2, minmax(0, 1fr)); }
+            .metric:nth-child(2) { border-right: 0; }
+            table, thead, tbody, tr, th, td { display: block; }
+            thead { display: none; }
+            tr { border-bottom: 1px solid var(--line); }
+            td { border-bottom: 0; padding: 12px 14px; }
+        }
+    </style>
+</head>
+<body>
+    <main>
+        <header>
+            <div>
+                <h1>Reporte de coleccion</h1>
+                <p>${escapeHtml(metadata.collectionLabel)} ejecutada con hasta ${metadata.concurrency} misiones simultaneas.</p>
+            </div>
+            <div class="badge">
+                <small>Estado general</small>
+                <strong>${failed > 0 ? 'Ejecucion con errores' : 'Ejecucion exitosa'}</strong>
+                <p>${escapeHtml(startedAt)} - ${escapeHtml(finishedAt)}</p>
+            </div>
+        </header>
+        <section class="grid">
+            <div class="metric"><b>${summary.length}</b><span>Misiones</span></div>
+            <div class="metric"><b>${passed}</b><span>Exitosas</span></div>
+            <div class="metric"><b>${failed}</b><span>Errores</span></div>
+            <div class="metric"><b>${Math.round(durationMs / 1000)}s</b><span>Tiempo acumulado</span></div>
+        </section>
+        <table>
+            <thead>
+                <tr>
+                    <th>Estado</th>
+                    <th>Mision</th>
+                    <th>Razon</th>
+                    <th>Duracion</th>
+                    <th>Evidencia</th>
+                </tr>
+            </thead>
+            <tbody>${rows}</tbody>
+        </table>
+    </main>
+</body>
+</html>`;
+
+    fs.writeFileSync(reportPath, html);
+    return { summaryPath, reportPath };
+}
+
+function openLocalFile(filePath) {
+    if (!filePath || !fs.existsSync(filePath)) return false;
+
+    try {
+        if (process.platform === 'win32') {
+            const child = spawn('cmd.exe', ['/d', '/s', '/c', 'start', '', filePath], {
+                detached: true,
+                stdio: 'ignore',
+                windowsHide: true
+            });
+            child.unref();
+        } else if (process.platform === 'darwin') {
+            const child = spawn('open', [filePath], { detached: true, stdio: 'ignore' });
+            child.unref();
+        } else {
+            const child = spawn('xdg-open', [filePath], { detached: true, stdio: 'ignore' });
+            child.unref();
+        }
+        return true;
+    } catch {
+        return false;
+    }
+}
+
+function openCollectionReport(reportPath) {
+    if (!reportPath || !fs.existsSync(reportPath) || process.env.CI === 'true') return;
+    if (!process.stdin.isTTY) return;
+
+    openLocalFile(reportPath);
+}
+
 async function runCollectionBatch({
     missionsRootDir,
     selectedCollection = null,
-    debug = false
+    debug = false,
+    concurrency = 1,
+    interactive = false
 }) {
     const collections = listMissionCollections(missionsRootDir);
     if (collections.length === 0) {
         note(chalk.yellow('No hay colecciones con misiones guardadas para ejecutar.'), 'Run All');
-        return;
+        return { summary: [], failed: 0 };
     }
 
     let targetCollections = collections;
@@ -664,7 +992,7 @@ async function runCollectionBatch({
 
     if (targetCollections.length === 0) {
         note(chalk.yellow('La coleccion solicitada no existe o no contiene misiones.'), 'Run All');
-        return;
+        return { summary: [], failed: 0 };
     }
 
     const missionsToRun = [];
@@ -681,38 +1009,114 @@ async function runCollectionBatch({
 
     if (missionsToRun.length === 0) {
         note(chalk.yellow('No se encontraron misiones ejecutables en la seleccion actual.'), 'Run All');
-        return;
+        return { summary: [], failed: 0 };
     }
 
+    const requestedConcurrency = normalizeCollectionConcurrency(
+        concurrency,
+        interactive ? COLLECTION_DEFAULT_CONCURRENCY : 1
+    );
+    const startedAt = new Date().toISOString();
+    const runId = createCollectionRunId();
+    const envInfo = setupEnvironment();
+    const runDir = path.join(envInfo.configDir, 'runs', runId);
+    const missionsRunDir = path.join(runDir, 'missions');
+    const collectionLabel = selectedCollection && selectedCollection !== '__ALL__'
+        ? (targetCollections[0]?.label || selectedCollection)
+        : `Todas las colecciones (${targetCollections.length})`;
+
+    if (!fs.existsSync(missionsRunDir)) fs.mkdirSync(missionsRunDir, { recursive: true });
+
     const sBatch = spinner();
     if (!debug) {
-        sBatch.start(`Ejecutando ${missionsToRun.length} misiones de ${targetCollections.length} coleccion(es)...`);
+        sBatch.start(`Preparando ${missionsToRun.length} misiones de ${targetCollections.length} coleccion(es)...`);
     }
 
     const summary = [];
+    const runnableMissions = [];
+    const usedSlugs = new Set();
+
     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));
+        const slug = createUniqueMissionSlug(missionSpec, missionEntry.file, index, usedSlugs);
+        const missionDir = path.join(missionsRunDir, slug);
+        const contextDir = path.join(missionDir, 'context');
+        const reportsDir = path.join(missionDir, 'reports');
+        const playwrightOutputDir = path.join(missionDir, 'playwright-output');
 
         if (!missionSpec.prompt) {
             summary.push({
+                index,
                 name: missionSpec.name || missionEntry.file,
                 collection: missionEntry.collection.label,
                 success: false,
-                reason: 'missing_prompt'
+                reason: 'missing_prompt',
+                durationMs: 0,
+                reportPath: null,
+                contextDir,
+                reportsDir,
+                playwrightOutputDir
             });
             continue;
         }
 
+        runnableMissions.push({
+            index,
+            missionEntry,
+            missionSpec,
+            collectionMeta,
+            discoverPath,
+            slug,
+            missionDir,
+            contextDir,
+            reportsDir,
+            playwrightOutputDir,
+            name: missionSpec.name || missionEntry.file,
+            collectionLabel: missionEntry.collection.label
+        });
+    }
+
+    const runnerPrebuilt = runnableMissions.length > 0
+        ? await buildRunnerForCollection(debug, sBatch)
+        : false;
+    let effectiveConcurrency = Math.min(requestedConcurrency, Math.max(1, runnableMissions.length));
+
+    if (!runnerPrebuilt && effectiveConcurrency > 1) {
+        effectiveConcurrency = 1;
+        note(
+            'No se pudo precompilar el runner antes del lote. Para evitar compilaciones simultaneas, esta coleccion se ejecutara de forma secuencial.',
+            'Concurrencia ajustada'
+        );
+    }
+
+    let completed = 0;
+    const runnableResults = await runWithConcurrency(runnableMissions, effectiveConcurrency, async (mission) => {
+        const startedMissionAt = Date.now();
+
         if (!debug) {
-            sBatch.message(`[${index + 1}/${missionsToRun.length}] ${missionSpec.name} (${missionEntry.collection.label})`);
+            sBatch.message(`[${completed}/${runnableMissions.length}] En curso hasta ${effectiveConcurrency}. Iniciando ${mission.name}`);
         } else {
-            console.log(chalk.cyan(`[RUN-ALL] ${index + 1}/${missionsToRun.length} -> ${missionSpec.name} [${missionEntry.collection.label}]`));
+            console.log(chalk.cyan(`[RUN-ALL] ${mission.index + 1}/${missionsToRun.length} -> ${mission.name} [${mission.collectionLabel}]`));
+        }
+
+        const childEnv = {
+            ...process.env,
+            ARCALITY_ROOT: PROJECT_ROOT,
+            ARCALITY_BATCH_MODE: 'true',
+            ARCALITY_RUN_DOMAIN_DIR: mission.missionDir,
+            ARCALITY_RUN_CONTEXT_DIR: mission.contextDir,
+            ARCALITY_RUN_REPORTS_DIR: mission.reportsDir,
+            ARCALITY_RUN_PLAYWRIGHT_OUTPUT_DIR: mission.playwrightOutputDir,
+            ARCALITY_COLLECTION_RUN_ID: runId,
+            ARCALITY_COLLECTION_MISSION_SLUG: mission.slug
+        };
+
+        if (runnerPrebuilt) {
+            childEnv.ARCALITY_RUNNER_PREBUILT = 'true';
         }
 
         try {
@@ -721,40 +1125,66 @@ async function runCollectionBatch({
                 '--agent',
                 '--batch',
                 '--skip-save-prompt',
-                `--discover=${discoverPath}`,
-                missionSpec.prompt
+                `--discover=${mission.discoverPath}`,
+                mission.missionSpec.prompt
             ], {
                 cwd: ORIGINAL_CWD,
-                env: {
-                    ...process.env,
-                    ARCALITY_ROOT: PROJECT_ROOT,
-                    ARCALITY_BATCH_MODE: 'true'
-                }
+                env: childEnv,
+                streamOutput: debug,
+                lastRunLog: path.join(mission.missionDir, 'last-run.log')
             });
 
-            const latestLog = readLatestMissionLog(contextDir, knownLogFiles);
+            const latestLog = readMissionResult(mission.missionDir, mission.contextDir);
             const success = latestLog?.data?.success === true;
-            summary.push({
-                name: missionSpec.name || missionEntry.file,
-                collection: missionEntry.collection.label,
+            return {
+                index: mission.index,
+                name: mission.name,
+                collection: mission.collectionLabel,
                 success,
                 reason: latestLog?.data?.fail_reason || null
-            });
+                    || (!latestLog ? 'missing_mission_log' : null),
+                durationMs: Date.now() - startedMissionAt,
+                reportPath: path.join(mission.reportsDir, 'index.html'),
+                contextDir: mission.contextDir,
+                reportsDir: mission.reportsDir
+            };
         } catch (error) {
-            summary.push({
-                name: missionSpec.name || missionEntry.file,
-                collection: missionEntry.collection.label,
+            return {
+                index: mission.index,
+                name: mission.name,
+                collection: mission.collectionLabel,
                 success: false,
-                reason: error instanceof Error ? error.message : 'runner_error'
-            });
+                reason: error instanceof Error ? error.message : 'runner_error',
+                durationMs: Date.now() - startedMissionAt,
+                reportPath: path.join(mission.reportsDir, 'index.html'),
+                contextDir: mission.contextDir,
+                reportsDir: mission.reportsDir
+            };
+        } finally {
+            completed += 1;
+            if (!debug) {
+                sBatch.message(`[${completed}/${runnableMissions.length}] Misiones terminadas. Concurrencia ${effectiveConcurrency}.`);
+            }
         }
-    }
+    });
+
+    summary.push(...runnableResults.filter(Boolean));
+    summary.sort((a, b) => a.index - b.index);
 
     const passed = summary.filter(item => item.success).length;
     const failed = summary.length - passed;
+    const artifacts = writeCollectionArtifacts(runDir, summary, {
+        runId,
+        collectionLabel,
+        concurrency: effectiveConcurrency,
+        startedAt
+    });
 
     if (!debug) {
-        sBatch.stop(chalk.green(`Coleccion ejecutada. Exitosas: ${passed} | Fallidas: ${failed}`));
+        const finalMessage = failed > 0
+            ? chalk.yellow(`Coleccion ejecutada. Exitosas: ${passed} | Fallidas: ${failed}`)
+            : chalk.green(`Coleccion ejecutada. Exitosas: ${passed} | Fallidas: ${failed}`);
+        sBatch.stop(finalMessage);
     }
 
     const lines = summary.map(item => {
@@ -763,288 +1193,311 @@ async function runCollectionBatch({
         return `- [${status}] ${item.collection} -> ${item.name}${reason}`;
     });
     note(lines.join('\n'), 'Resumen Run All');
+    note(
+        `Resumen JSON: ${artifacts.summaryPath}\nReporte HTML: ${artifacts.reportPath}\nNota: la ejecucion paralela abre varias sesiones del portal. Arcality no puede validar reglas internas de sesion, bloqueo de usuario o datos compartidos del sistema probado.`,
+        'Evidencia de coleccion'
+    );
+
+    openCollectionReport(artifacts.reportPath);
+    return { summary, failed, runDir, reportPath: artifacts.reportPath };
 }
 
 function showBanner() {
-    console.clear();
-
-    let version = 'unknown';
-    try {
-        const pkg = JSON.parse(fs.readFileSync(path.join(PROJECT_ROOT, 'package.json'), 'utf8'));
-        version = pkg.version || 'unknown';
-    } catch { }
-
-    const sentinelAscii = `
- █████  ██████   ██████  █████  ██      ██ ████████ ██    ██ 
-██   ██ ██   ██ ██      ██   ██ ██      ██    ██     ██  ██  
-███████ ██████  ██      ███████ ██      ██    ██      ████   
-██   ██ ██   ██ ██      ██   ██ ██      ██    ██       ██    
-██   ██ ██   ██  ██████ ██   ██ ███████ ██    ██       ██    `;
-
-    intro(chalk.gray(sentinelAscii));
-
-    note(
-        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.gray('Versión del Sistema: ') + chalk.white(`v${version}`),
-        'Estado Central de Arcality'
-    );
-
-    const { configName, baseUrl, techStack, configDir } = setupEnvironment();
-
-    // Show arcality.config status instead of multi-config switching
-    const hasConfig = !!projectConfig;
-    const configStatus = hasConfig
-        ? 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('NO VERIFICADO');
-
-    const infoLines = [
-        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.gray('Proyecto:     ') + chalk.white(configName) + chalk.gray(` [${baseUrl}]`),
-            chalk.gray('ID de Identidad: ') + chalk.white(projectConfig.projectId || 'N/A'),
-        );
-    } else {
-        infoLines.push(chalk.gray('Configuración:      ') + configStatus);
-    }
-
-    note(infoLines.join('\n'), 'Telemetría del Objetivo');
-}
-
-const ARCALITY_BRAIN_URL = "https://api.anthropic.com/v1/messages";
-const ARCALITY_MODEL = process.env.CLAUDE_MODEL || "claude-4-5-sonnet-latest";
-const OUT_DIR = path.join(PROJECT_ROOT, "tests");
-const LOGS_DIR = path.join(PROJECT_ROOT, "logs");
-
-async function arcalityChat(messages) {
-    const internalApiUrl = getApiUrl();
-    const isProxyMode = !!internalApiUrl;
-
-    if (!process.env.ANTHROPIC_API_KEY && !isProxyMode) {
-        throw new Error("Missing ANTHROPIC_API_KEY in .env");
-    }
-
-    const systemMessage = messages.find(m => m.role === 'system');
-    const userMessages = messages.filter(m => m.role !== 'system');
-
-    try {
-        const endpointUrl = isProxyMode
-            ? `${internalApiUrl}/api/v1/ai/proxy`
-            : ARCALITY_BRAIN_URL;
-
-        const headers = {
-            "Content-Type": "application/json"
-        };
-
-        if (isProxyMode) {
-            headers["x-api-key"] = process.env.ARCALITY_API_KEY || "";
-            const missionId = process.env.ARCALITY_MISSION_ID || '';
-            if (missionId) headers["x-mission-id"] = missionId;
-        } else {
-            headers["x-api-key"] = process.env.ANTHROPIC_API_KEY;
-            headers["anthropic-version"] = "2023-06-01";
-        }
-
-        const res = await fetch(endpointUrl, {
-            method: "POST",
-            headers,
-            body: JSON.stringify({
-                model: ARCALITY_MODEL,
-                system: systemMessage ? systemMessage.content : undefined,
-                messages: userMessages,
-                max_tokens: 4000,
-                temperature: 0.3
-            })
-        });
-
-        if (!res.ok) {
-            const txt = await res.text();
-            throw new Error(`Arcality Brain Error ${res.status}: ${txt}`);
-        }
-
-        const data = await res.json();
-        const content = data.content?.[0]?.text || "";
-
-        try {
-            if (!fs.existsSync(LOGS_DIR)) fs.mkdirSync(LOGS_DIR, { recursive: true });
-            fs.writeFileSync(path.join(LOGS_DIR, 'last-ai-response.txt'), content);
-        } catch (e) { /* ignore */ }
-
-        return content;
-    } catch (err) {
-        throw new Error(`Error communicating with Arcality brain: ${err.message}`);
-    }
-}
-
-function extractBlocks(text) {
-    const cleaned = text
-        .replace(/```[a-zA-Z]*\n?/g, "")
-        .replace(/```/g, "")
-        .trim();
-
-    const fnMatch = cleaned.match(/^FILENAME:\s*(.+)$/m);
-    const contentIdx = cleaned.indexOf("CONTENT:");
-
-    if (!fnMatch || contentIdx === -1) {
-        throw new Error(
-            `Invalid format. Expected:\nFILENAME: <file.spec.ts>\nCONTENT:\n<code>\n\nResponse:\n${cleaned}`
-        );
-    }
-
-    const filename = fnMatch[1].trim();
-    const content = cleaned.slice(contentIdx + "CONTENT:".length).trim();
-
-    return { filename, content, cleaned };
-}
-
-function validateSpec(ts) {
-    const errors = [];
-    if (!/test\s*\(.*async\s*\(\s*\{\s*page\s*\}\s*\)\s*=>/s.test(ts)) {
-        errors.push('Missing fixture: test("...", async ({ page }) => { ... })');
-    }
-    if (/from\s+['"]playwright['"]/.test(ts)) {
-        errors.push("Forbidden to import from core. Use only the Arcality SDK.");
-    }
-    if (!ts.includes("import { test, expect } from '@playwright/test'")) {
-        errors.push("Must import exactly the Arcality engine.");
-    }
-    return errors;
-}
-
-function sanitizeFilename(name, fallback) {
-    if (typeof name !== "string") return fallback;
-    const safe = name.trim().replace(/[<>:"/\\|?*\u0000-\u001F]/g, "_");
-    if (!safe.endsWith(".spec.ts")) return fallback;
-    return safe;
-}
-
-function run(cmd, args, options = {}) {
-    const isDebug = process.argv.includes('--debug');
-    const cwd = options.cwd || process.cwd();
-
-    return new Promise((resolve, reject) => {
-        // NODE_PATH: let Node resolve modules from both the arcality package and user's project
-        const appNodeModules = path.join(PROJECT_ROOT, 'node_modules');
-        const userNodeModules = path.join(ORIGINAL_CWD, 'node_modules');
-        const existingNodePath = process.env.NODE_PATH || '';
-        const newNodePath = [appNodeModules, userNodeModules, existingNodePath].filter(Boolean).join(path.delimiter);
-
-        const env = { ...options.env || process.env, NODE_PATH: newNodePath };
-        if (isDebug) console.log(chalk.gray(`\n[DEBUG] CWD: ${cwd}`));
-        if (isDebug) console.log(chalk.gray(`[DEBUG] Running: ${cmd} ${args.join(' ')}`));
-
-        // Use standard cross-platform spawn. When shell is false, Node's child_process 
-        // properly wraps arguments with spaces in quotes natively for CreateProcessW on Windows.
-        //
-        // CRITICAL (Windows): stdin MUST be 'ignore' (not 'inherit') to prevent cmd.exe from
-        // showing the "¿Desea terminar el trabajo por lotes (S/N)?" prompt on Ctrl+C.
-        // When stdin is 'inherit', cmd.exe intercepts Ctrl+C at the console level and kills
-        // the entire process tree before our SIGINT handler can run, bypassing the finally block.
-        const p = spawn(cmd, args, {
-            stdio: isDebug ? ['ignore', 'inherit', 'inherit'] : ['ignore', 'pipe', 'pipe'],
-            shell: false,
-            cwd,
-            env,
-        });
-
-        // Exponer el proceso hijo para que el cancelHandler pueda matarlo
-        if (options.onSpawn) options.onSpawn(p);
-
-        let outputBuffer = '';
-        const handleData = (data) => {
-            const str = data.toString();
-            outputBuffer += str;
-
-            if (str.includes('>>ARCALITY_STATUS>>')) {
-                const lines = str.split('\n');
-                for (const line of lines) {
-                    if (line.includes('>>ARCALITY_STATUS>>')) {
-                        const status = line.split('>>ARCALITY_STATUS>>')[1].trim();
-                        if (options.onStatus) options.onStatus(status);
-                    } else if (line.trim()) {
-                        process.stdout.write(line + '\n');
-                    }
-                }
-            } else {
-                process.stdout.write(data);
-            }
-        };
-
-        if (p.stdout) p.stdout.on('data', handleData);
-        if (p.stderr) {
-            p.stderr.on('data', (data) => {
-                if (isDebug) process.stderr.write(data);
-                else process.stderr.write(data);
-                outputBuffer += data.toString();
-            });
-        }
-
-        p.on('exit', (code, signal) => {
-            const lastRunLog = path.join(LOGS_DIR, 'last-run.log');
-            try {
-                if (!fs.existsSync(LOGS_DIR)) fs.mkdirSync(LOGS_DIR, { recursive: true });
-                fs.writeFileSync(lastRunLog, outputBuffer);
-            } catch (e) { }
-
-            // code===0 → clean success
-            // code===null + signal → killed by signal (Ctrl+C) — treat as non-fatal so finally runs
-            // code===1 → test failed (Playwright returns 1 on test failure) — also non-fatal
-            if (code === 0 || signal !== null || code === 1) resolve();
-            else {
-                if (isDebug) console.error(chalk.red(`\n[DEBUG] Process exited with code ${code}`));
-                reject(new Error(`Process exited with code ${code}`));
-            }
-        });
-
-        p.on('error', (err) => {
-            if (isDebug) console.error(chalk.red(`\n[DEBUG] Process failed to spawn: ${err.message}`));
-            reject(err);
-        });
-    });
-}
-
-/**
- * Ping the project to register activity.
- * Uses internal API URL — not user-configurable.
- */
-async function pingProject(projectId, apiKey) {
-    if (!projectId || !apiKey) return;
-    try {
-        await fetch(`${getApiUrl()}/api/v1/projects/${projectId}/ping`, {
-            method: 'PATCH',
-            headers: { 'x-api-key': apiKey },
-        });
-    } catch { /* silent */ }
-}
-
-async function main() {
-    process.chdir(PROJECT_ROOT);
-
-    // Backward compat: initialize .env if ACTIVE_CONFIG missing (legacy)
-    let initialEnv = parseDotEnvFile(path.join(PROJECT_ROOT, '.env'));
-    if (!projectConfig && !initialEnv.ACTIVE_CONFIG) {
-        updateDotEnvFile({
-            ACTIVE_CONFIG: 'Default',
-            SAVED_CONFIGS: 'Default',
-            Default_URL: initialEnv.BASE_URL || '',
-            Default_USER: initialEnv.LOGIN_USER || '',
-            Default_PASS: initialEnv.LOGIN_PASSWORD || ''
-        });
-        initialEnv = parseDotEnvFile(path.join(PROJECT_ROOT, '.env'));
-    }
-
+    console.clear();
+
+    let version = 'unknown';
+    try {
+        const pkg = JSON.parse(fs.readFileSync(path.join(PROJECT_ROOT, 'package.json'), 'utf8'));
+        version = pkg.version || 'unknown';
+    } catch { }
+
+    const sentinelAscii = `
+ █████  ██████   ██████  █████  ██      ██ ████████ ██    ██ 
+██   ██ ██   ██ ██      ██   ██ ██      ██    ██     ██  ██  
+███████ ██████  ██      ███████ ██      ██    ██      ████   
+██   ██ ██   ██ ██      ██   ██ ██      ██    ██       ██    
+██   ██ ██   ██  ██████ ██   ██ ███████ ██    ██       ██    `;
+
+    intro(chalk.gray(sentinelAscii));
+
+    note(
+        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.gray('Versión del Sistema: ') + chalk.white(`v${version}`),
+        'Estado Central de Arcality'
+    );
+
+    const { configName, baseUrl, techStack, configDir } = setupEnvironment();
+
+    // Show arcality.config status instead of multi-config switching
+    const hasConfig = !!projectConfig;
+    const configStatus = hasConfig
+        ? 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('NO VERIFICADO');
+
+    const infoLines = [
+        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.gray('Proyecto:     ') + chalk.white(configName) + chalk.gray(` [${baseUrl}]`),
+            chalk.gray('ID de Identidad: ') + chalk.white(projectConfig.projectId || 'N/A'),
+        );
+    } else {
+        infoLines.push(chalk.gray('Configuración:      ') + configStatus);
+    }
+
+    note(infoLines.join('\n'), 'Telemetría del Objetivo');
+}
+
+const ARCALITY_BRAIN_URL = "https://api.anthropic.com/v1/messages";
+const ARCALITY_MODEL = process.env.CLAUDE_MODEL || "claude-4-5-sonnet-latest";
+const OUT_DIR = path.join(PROJECT_ROOT, "tests");
+const LOGS_DIR = path.join(PROJECT_ROOT, "logs");
+
+async function arcalityChat(messages) {
+    const internalApiUrl = getApiUrl();
+    const isProxyMode = !!internalApiUrl;
+
+    if (!process.env.ANTHROPIC_API_KEY && !isProxyMode) {
+        throw new Error("Missing ANTHROPIC_API_KEY in .env");
+    }
+
+    const systemMessage = messages.find(m => m.role === 'system');
+    const userMessages = messages.filter(m => m.role !== 'system');
+
+    try {
+        const endpointUrl = isProxyMode
+            ? `${internalApiUrl}/api/v1/ai/proxy`
+            : ARCALITY_BRAIN_URL;
+
+        const headers = {
+            "Content-Type": "application/json"
+        };
+
+        if (isProxyMode) {
+            headers["x-api-key"] = process.env.ARCALITY_API_KEY || "";
+            const missionId = process.env.ARCALITY_MISSION_ID || '';
+            if (missionId) headers["x-mission-id"] = missionId;
+        } else {
+            headers["x-api-key"] = process.env.ANTHROPIC_API_KEY;
+            headers["anthropic-version"] = "2023-06-01";
+        }
+
+        const res = await fetch(endpointUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({
+                model: ARCALITY_MODEL,
+                system: systemMessage ? systemMessage.content : undefined,
+                messages: userMessages,
+                max_tokens: 4000,
+                temperature: 0.3
+            })
+        });
+
+        if (!res.ok) {
+            const txt = await res.text();
+            throw new Error(`Arcality Brain Error ${res.status}: ${txt}`);
+        }
+
+        const data = await res.json();
+        const content = data.content?.[0]?.text || "";
+
+        try {
+            if (!fs.existsSync(LOGS_DIR)) fs.mkdirSync(LOGS_DIR, { recursive: true });
+            fs.writeFileSync(path.join(LOGS_DIR, 'last-ai-response.txt'), content);
+        } catch (e) { /* ignore */ }
+
+        return content;
+    } catch (err) {
+        throw new Error(`Error communicating with Arcality brain: ${err.message}`);
+    }
+}
+
+function extractBlocks(text) {
+    const cleaned = text
+        .replace(/```[a-zA-Z]*\n?/g, "")
+        .replace(/```/g, "")
+        .trim();
+
+    const fnMatch = cleaned.match(/^FILENAME:\s*(.+)$/m);
+    const contentIdx = cleaned.indexOf("CONTENT:");
+
+    if (!fnMatch || contentIdx === -1) {
+        throw new Error(
+            `Invalid format. Expected:\nFILENAME: <file.spec.ts>\nCONTENT:\n<code>\n\nResponse:\n${cleaned}`
+        );
+    }
+
+    const filename = fnMatch[1].trim();
+    const content = cleaned.slice(contentIdx + "CONTENT:".length).trim();
+
+    return { filename, content, cleaned };
+}
+
+function validateSpec(ts) {
+    const errors = [];
+    if (!/test\s*\(.*async\s*\(\s*\{\s*page\s*\}\s*\)\s*=>/s.test(ts)) {
+        errors.push('Missing fixture: test("...", async ({ page }) => { ... })');
+    }
+    if (/from\s+['"]playwright['"]/.test(ts)) {
+        errors.push("Forbidden to import from core. Use only the Arcality SDK.");
+    }
+    if (!ts.includes("import { test, expect } from '@playwright/test'")) {
+        errors.push("Must import exactly the Arcality engine.");
+    }
+    return errors;
+}
+
+function sanitizeFilename(name, fallback) {
+    if (typeof name !== "string") return fallback;
+    const safe = name.trim().replace(/[<>:"/\\|?*\u0000-\u001F]/g, "_");
+    if (!safe.endsWith(".spec.ts")) return fallback;
+    return safe;
+}
+
+function run(cmd, args, options = {}) {
+    const isDebug = process.argv.includes('--debug');
+    const cwd = options.cwd || process.cwd();
+    const streamOutput = options.streamOutput !== false || isDebug;
+
+    return new Promise((resolve, reject) => {
+        // NODE_PATH: let Node resolve modules from both the arcality package and user's project
+        const appNodeModules = path.join(PROJECT_ROOT, 'node_modules');
+        const userNodeModules = path.join(ORIGINAL_CWD, 'node_modules');
+        const existingNodePath = process.env.NODE_PATH || '';
+        const newNodePath = [appNodeModules, userNodeModules, existingNodePath].filter(Boolean).join(path.delimiter);
+
+        const env = { ...options.env || process.env, NODE_PATH: newNodePath };
+        if (isDebug) console.log(chalk.gray(`\n[DEBUG] CWD: ${cwd}`));
+        if (isDebug) console.log(chalk.gray(`[DEBUG] Running: ${cmd} ${args.join(' ')}`));
+
+        // Use standard cross-platform spawn. When shell is false, Node's child_process 
+        // properly wraps arguments with spaces in quotes natively for CreateProcessW on Windows.
+        //
+        // CRITICAL (Windows): stdin MUST be 'ignore' (not 'inherit') to prevent cmd.exe from
+        // showing the "¿Desea terminar el trabajo por lotes (S/N)?" prompt on Ctrl+C.
+        // When stdin is 'inherit', cmd.exe intercepts Ctrl+C at the console level and kills
+        // the entire process tree before our SIGINT handler can run, bypassing the finally block.
+        const p = spawn(cmd, args, {
+            stdio: isDebug ? ['ignore', 'inherit', 'inherit'] : ['ignore', 'pipe', 'pipe'],
+            shell: false,
+            cwd,
+            env,
+        });
+
+        // Exponer el proceso hijo para que el cancelHandler pueda matarlo
+        if (options.onSpawn) options.onSpawn(p);
+
+        let outputBuffer = '';
+        const handleData = (data) => {
+            const str = data.toString();
+            outputBuffer += str;
+
+            if (str.includes('>>ARCALITY_STATUS>>')) {
+                const lines = str.split('\n');
+                for (const line of lines) {
+                    if (line.includes('>>ARCALITY_STATUS>>')) {
+                        const status = line.split('>>ARCALITY_STATUS>>')[1].trim();
+                        if (options.onStatus) options.onStatus(status);
+                    } else if (line.trim() && streamOutput) {
+                        process.stdout.write(line + '\n');
+                    }
+                }
+            } else if (streamOutput) {
+                process.stdout.write(data);
+            }
+        };
+
+        if (p.stdout) p.stdout.on('data', handleData);
+        if (p.stderr) {
+            p.stderr.on('data', (data) => {
+                if (streamOutput) process.stderr.write(data);
+                outputBuffer += data.toString();
+            });
+        }
+
+        p.on('exit', (code, signal) => {
+            const lastRunLog = options.lastRunLog || path.join(LOGS_DIR, 'last-run.log');
+            try {
+                const lastRunLogDir = path.dirname(lastRunLog);
+                if (!fs.existsSync(lastRunLogDir)) fs.mkdirSync(lastRunLogDir, { recursive: true });
+                fs.writeFileSync(lastRunLog, outputBuffer);
+            } catch (e) { }
+
+            // code===0 → clean success
+            // code===null + signal → killed by signal (Ctrl+C) — treat as non-fatal so finally runs
+            // code===1 → test failed (Playwright returns 1 on test failure) — also non-fatal
+            if (code === 0 || signal !== null || code === 1) resolve();
+            else {
+                if (isDebug) console.error(chalk.red(`\n[DEBUG] Process exited with code ${code}`));
+                reject(new Error(`Process exited with code ${code}`));
+            }
+        });
+
+        p.on('error', (err) => {
+            if (isDebug) console.error(chalk.red(`\n[DEBUG] Process failed to spawn: ${err.message}`));
+            reject(err);
+        });
+    });
+}
+
+function runNpmScript(args, options = {}) {
+    if (process.platform === 'win32') {
+        return run('cmd.exe', ['/d', '/s', '/c', 'npm.cmd', ...args], options);
+    }
+    return run('npm', args, options);
+}
+
+/**
+ * Ping the project to register activity.
+ * Uses internal API URL — not user-configurable.
+ */
+async function pingProject(projectId, apiKey) {
+    if (!projectId || !apiKey) return;
+    try {
+        await fetch(`${getApiUrl()}/api/v1/projects/${projectId}/ping`, {
+            method: 'PATCH',
+            headers: { 'x-api-key': apiKey },
+        });
+    } catch { /* silent */ }
+}
+
+async function main() {
+    process.chdir(PROJECT_ROOT);
+
+    // Backward compat: initialize .env if ACTIVE_CONFIG missing (legacy)
+    let initialEnv = parseDotEnvFile(path.join(PROJECT_ROOT, '.env'));
+    const envProjectId = initialEnv.ARCALITY_PROJECT_ID || process.env.ARCALITY_PROJECT_ID;
+    if (envProjectId && !isRealProjectId(envProjectId)) {
+        console.error(chalk.red('\n[FATAL] ARCALITY_PROJECT_ID invalido.'));
+        console.error(chalk.yellow('La herramienta no acepta Project IDs locales o mock.'));
+        console.error(chalk.gray('Ejecuta `arcality init` para registrar el proyecto en Arcality.\n'));
+        process.exit(1);
+    }
+
+    if (!projectConfig && !initialEnv.ACTIVE_CONFIG) {
+        updateDotEnvFile({
+            ACTIVE_CONFIG: 'Default',
+            SAVED_CONFIGS: 'Default',
+            Default_URL: initialEnv.BASE_URL || '',
+            Default_USER: initialEnv.LOGIN_USER || '',
+            Default_PASS: initialEnv.LOGIN_PASSWORD || ''
+        });
+        initialEnv = parseDotEnvFile(path.join(PROJECT_ROOT, '.env'));
+    }
+
     const argv = process.argv.slice(2);
     let initialDiscoverPath = null;
     let initialSmartMode = false;
@@ -1054,6 +1507,7 @@ async function main() {
     let initialSkipSavePrompt = process.env.ARCALITY_SKIP_SAVE_PROMPT === 'true';
     let initialBatchMode = process.env.ARCALITY_BATCH_MODE === 'true';
     let initialCollectionPath = null;
+    let initialCollectionConcurrency = null;
 
     const dIndex = argv.findIndex(a => a === '--discover' || a.startsWith('--discover='));
     if (dIndex !== -1) {
@@ -1084,16 +1538,26 @@ async function main() {
         }
         argv.splice(collectionIndex, 1);
     }
+    const concurrencyIndex = argv.findIndex(a => a === '--concurrency' || a.startsWith('--concurrency=') || a === '--parallel' || a.startsWith('--parallel='));
+    if (concurrencyIndex !== -1) {
+        const token = argv[concurrencyIndex];
+        if (token.includes('=')) initialCollectionConcurrency = normalizeCollectionConcurrency(token.split('=')[1], 1);
+        else if (argv[concurrencyIndex + 1]) {
+            initialCollectionConcurrency = normalizeCollectionConcurrency(argv[concurrencyIndex + 1], 1);
+            argv.splice(concurrencyIndex + 1, 1);
+        }
+        argv.splice(concurrencyIndex, 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;
-    let globalReportProcess = null;
-
-    setupEnvironment();
-
-    while (true) {
+
+    const promptArg = argv.join(" ").trim();
+    let firstRun = true;
+    let globalReportProcess = null;
+
+    setupEnvironment();
+
+    while (true) {
         let prompt = firstRun ? promptArg : "";
         let agentMode = firstRun ? initialAgentMode : false;
         let smartMode = firstRun ? initialSmartMode : false;
@@ -1101,6 +1565,7 @@ async function main() {
         let runAllMode = firstRun ? initialRunAllMode : false;
         let templateMode = firstRun ? initialTemplateMode : false;
         let collectionPath = firstRun ? initialCollectionPath : null;
+        let collectionConcurrency = firstRun ? initialCollectionConcurrency : null;
         let skipSavePrompt = firstRun ? initialSkipSavePrompt : false;
         let batchMode = firstRun ? initialBatchMode : false;
 
@@ -1108,31 +1573,31 @@ async function main() {
         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;
+                // ── Build menu options (single config mode) ──
+                const missionsDir = process.env.MISSIONS_DIR;
                 const savedMissionCollections = listMissionCollections(missionsDir);
-
-                // Check for YAML files in the yaml output dir from arcality.config
+
+                // Check for YAML files in the yaml output dir from arcality.config
                 let projectMissionCollections = [];
-                if (projectConfig) {
-                    const yamlDir = getYamlOutputDir(projectConfig, ORIGINAL_CWD);
-                    if (fs.existsSync(yamlDir)) {
+                if (projectConfig) {
+                    const yamlDir = getYamlOutputDir(projectConfig, ORIGINAL_CWD);
+                    if (fs.existsSync(yamlDir)) {
                         projectMissionCollections = listMissionCollections(yamlDir);
-                    }
-                }
-
-                // Root-level YAML templates
+                    }
+                }
+
+                // Root-level YAML templates
                 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' }] : []),
@@ -1143,7 +1608,7 @@ async function main() {
                     { 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'
@@ -1160,15 +1625,15 @@ async function main() {
                 }
 
                 const action = await select({
-                    message: '¿Qué te gustaría hacer?',
+                    message: '¿Qué te gustaría hacer?',
                     options: menuOptions
                 });
-
-                if (isCancel(action) || action === 'exit') {
-                    outro(chalk.cyan('¡Hasta luego!'));
-                    break;
-                }
-
+
+                if (isCancel(action) || action === 'exit') {
+                    outro(chalk.cyan('¡Hasta luego!'));
+                    break;
+                }
+
                 if (action === 'agent') {
                     agentMode = true;
                 } else if (action === 'run_collection') {
@@ -1204,33 +1669,33 @@ async function main() {
                     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 {
-                        await new Promise((resolve, reject) => {
-                            const child = spawn('node', [initScript], {
-                                stdio: 'inherit',
-                                cwd: ORIGINAL_CWD,
-                                env: { ...process.env, ARCALITY_ROOT: PROJECT_ROOT }
-                            });
-                            child.on('exit', code => code === 0 ? resolve() : reject(new Error(`Init exited with ${code}`)));
-                            child.on('error', reject);
-                        });
-                        
-                        // ── REFRESH CONFIG ──
-                        // Recargar el archivo que init.mjs acaba de escribir
-                        projectConfig = loadProjectConfig(ORIGINAL_CWD) || loadProjectConfig(PROJECT_ROOT);
-                        if (projectConfig) {
-                            injectConfigToEnv(projectConfig);
-                        }
-                        setupEnvironment();
-                        
-                    } catch (e) {
-                        // Mostrar el error claramente antes de que console.clear() lo borre
-                        console.log(chalk.red(`\n❌ Reconfigure failed: ${e.message}`));
-                        await new Promise(r => setTimeout(r, 3000));
-                    }
-                    continue;
+                    // Launch arcality init in the user's project directory
+                    const initScript = path.join(PROJECT_ROOT, 'scripts', 'init.mjs');
+                    try {
+                        await new Promise((resolve, reject) => {
+                            const child = spawn('node', [initScript], {
+                                stdio: 'inherit',
+                                cwd: ORIGINAL_CWD,
+                                env: { ...process.env, ARCALITY_ROOT: PROJECT_ROOT }
+                            });
+                            child.on('exit', code => code === 0 ? resolve() : reject(new Error(`Init exited with ${code}`)));
+                            child.on('error', reject);
+                        });
+                        
+                        // ── REFRESH CONFIG ──
+                        // Recargar el archivo que init.mjs acaba de escribir
+                        projectConfig = loadProjectConfig(ORIGINAL_CWD) || loadProjectConfig(PROJECT_ROOT);
+                        if (projectConfig) {
+                            injectConfigToEnv(projectConfig);
+                        }
+                        setupEnvironment();
+                        
+                    } catch (e) {
+                        // Mostrar el error claramente antes de que console.clear() lo borre
+                        console.log(chalk.red(`\n❌ Reconfigure failed: ${e.message}`));
+                        await new Promise(r => setTimeout(r, 3000));
+                    }
+                    continue;
                 } else if (action === 'launch_saved') {
                     const selectedMission = await selectMissionYaml(
                         missionsDir,
@@ -1262,8 +1727,8 @@ async function main() {
                     const sel = await select({
                         message: 'Elige el archivo YAML:',
                         options: rootYamlFiles.map(f => ({ label: f, value: f }))
-                    });
-                    if (isCancel(sel)) continue;
+                    });
+                    if (isCancel(sel)) continue;
 
                     const yamlContent = fs.readFileSync(path.join(PROJECT_ROOT, sel), 'utf8');
                     const missionSpec = normalizeMissionSpec(loadYaml(yamlContent), path.join(PROJECT_ROOT, sel));
@@ -1271,9 +1736,9 @@ async function main() {
                     discoverPath = getMissionStartPath(missionSpec);
                     agentMode = true;
                 }
-            } catch (e) {
-                console.error("Menu error:", e);
-                break;
+            } catch (e) {
+                console.error("Menu error:", e);
+                break;
             }
         }
 
@@ -1314,10 +1779,38 @@ async function main() {
                 batchCollection = selectedBatchCollection;
             }
 
+            let batchConcurrency = normalizeCollectionConcurrency(
+                collectionConcurrency,
+                skipMenu ? 1 : COLLECTION_DEFAULT_CONCURRENCY
+            );
+
+            if (!skipMenu && process.stdin.isTTY) {
+                note(
+                    'La ejecucion paralela abre varias sesiones del portal al mismo tiempo. Arcality no puede conocer ni validar reglas internas de sesion, bloqueo por usuario, datos compartidos o limites del sistema probado; si tu portal no permite sesiones paralelas con el mismo usuario, usa 1.',
+                    'Sesiones del portal'
+                );
+
+                const selectedConcurrency = await select({
+                    message: 'Cuantas misiones quieres ejecutar al mismo tiempo?',
+                    options: [
+                        { label: `3 simultaneas (recomendado)`, value: 3 },
+                        { label: '1 secuencial', value: 1 },
+                        { label: '5 simultaneas (maximo)', value: 5 }
+                    ]
+                });
+                if (isCancel(selectedConcurrency)) {
+                    if (skipMenu) return;
+                    continue;
+                }
+                batchConcurrency = normalizeCollectionConcurrency(selectedConcurrency, COLLECTION_DEFAULT_CONCURRENCY);
+            }
+
             await runCollectionBatch({
                 missionsRootDir: process.env.MISSIONS_DIR,
                 selectedCollection: batchCollection || '__ALL__',
-                debug: process.argv.includes('--debug')
+                debug: process.argv.includes('--debug'),
+                concurrency: batchConcurrency,
+                interactive: !skipMenu
             });
 
             if (skipMenu) return;
@@ -1326,443 +1819,495 @@ async function main() {
 
         // --- 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):'),
-                    placeholder: 'Ej., Llena el formulario de registro con datos aleatorios',
-                    validate: v => {
-                        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('Misión cancelada. Regresando al menú principal...');
-                    agentMode = false;
-                    prompt = "";
-                    skipMenu = false;
-                    continue;
-                }
-                prompt = p;
-            }
-
-            if (!discoverPath) {
-                const knownBaseUrl = projectConfig?.project?.baseUrl || process.env.BASE_URL;
-                const promptMsg = knownBaseUrl
-                    ? `🌐 Initial navigation path (relative to ${knownBaseUrl}):`
-                    : '🌐 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 'Por favor provee una URL completa con http:// o https://';
-                        return undefined;
-                    }
-                });
-
-                if (isCancel(d)) {
-                    cancel('Misión abortada. Regresando al menú...');
-                    agentMode = false;
-                    prompt = "";
-                    skipMenu = false;
-                    continue;
-                }
-                discoverPath = d;
-            }
-        }
-
-        if (agentMode) {
-            // Load environment from BOTH the user's project and the library's root
-            const userDotEnv = parseDotEnvFile(path.join(ORIGINAL_CWD, '.env'));
-            const libDotEnv = parseDotEnvFile(path.join(PROJECT_ROOT, '.env'));
-            const dotEnv = { ...userDotEnv, ...libDotEnv };
-
-            // ── API Key and Quota Validation ──
-            const { validateApiKey, startMission: requestMission } = await import('../src/arcalityClient.mjs');
-
-            const validation = await validateApiKey();
-            if (process.env.DEBUG || process.argv.includes('--debug')) {
-                console.log(chalk.gray(`[DEBUG] Validation result: ${JSON.stringify(validation, null, 2)}`));
-            }
-            
-            const detectedOrgId = validation.organization_id || validation.organizationId || validation.OrganizationId;
-            if (detectedOrgId) {
-                process.env.ARCALITY_ORG_ID = detectedOrgId;
-            }
-            if (!validation.valid) {
-                const errorMessages = {
-                    '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}`), '❌ Autenticación');
-                agentMode = false;
-                prompt = "";
-                skipMenu = false;
-                continue;
-            }
-
-            // Show plan info
-            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.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 ---
-            let selectedProjectId = projectConfig?.projectId || dotEnv.ARCALITY_PROJECT_ID || process.env.ARCALITY_PROJECT_ID;
-            const apiBase = getApiUrl();
-
-            if (!selectedProjectId) {
-                // If no project ID from config, try to create/select from backend
-                try {
-                    const projController = new AbortController();
-                    const projTimeout = setTimeout(() => projController.abort(), 5000);
-                    const projRes = await fetch(`${apiBase}/api/v1/projects`, {
-                        headers: { 'x-api-key': process.env.ARCALITY_API_KEY || '' },
-                        signal: projController.signal
-                    });
-                    clearTimeout(projTimeout);
-
-                    if (projRes.ok) {
-                        const data = await projRes.json();
-                        const projects = data.projects || [];
-
-                        const projOptions = projects.map(p => ({ label: p.name || p.Name, value: p.id || p.Id }));
-                        projOptions.push({ label: '➕ Crear nuevo proyecto', value: 'new' });
-
-                        const projSelection = await select({
-                            message: chalk.cyan('Elige un proyecto para esta misión:'),
-                            options: projOptions
-                        });
-
-                        if (isCancel(projSelection)) {
-                            cancel('Misión abortada.');
-                            agentMode = false; prompt = ""; skipMenu = false; continue;
-                        }
-
-                        if (projSelection === 'new') {
-                            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',
-                                headers: { 'Content-Type': 'application/json', 'x-api-key': process.env.ARCALITY_API_KEY || '' },
-                                body: JSON.stringify({
-                                    name: newName,
-                                    base_url: projectConfig?.project?.baseUrl || discoverPath || '/',
-                                    arcality_version: projectConfig?.meta?.arcalityVersion || 'unknown',
-                                    config: { source: 'npm-cli', single_configuration_mode: true, yaml_reuse_enabled: true }
-                                })
-                            });
-
-                            if (createRes.ok) {
-                                const created = await createRes.json();
-                                selectedProjectId = created.id || created.Id;
-                                note(chalk.green(`✅ Proyecto creado: ${newName}`));
-                            } else {
-                                note(chalk.red(`❌ Falló al crear proyecto.`));
-                            }
-                        } else {
-                            selectedProjectId = projSelection;
-                        }
-
-                        if (selectedProjectId) {
-                            process.env.ARCALITY_PROJECT_ID = selectedProjectId;
-                        }
-                    }
-                } catch (e) {
-                    console.log(chalk.yellow(`\n⚠️ Error connecting to project server: ${e.message}. Using default.`));
-                }
-            } else {
-                process.env.ARCALITY_PROJECT_ID = selectedProjectId;
-            }
-
-            // ── Start Mission ──
-            const mission = await requestMission(prompt, discoverPath || '/');
-            if (!mission.allowed) {
-                note(
-                    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'}`),
-                    '⚠️ Límite Alcanzado'
-                );
-                agentMode = false;
-                prompt = "";
-                skipMenu = false;
-                continue;
-            }
-
-            const s = spinner();
-            if (!process.argv.includes('--debug')) {
-                s.start(`◉ [ARCALITY INICIADO] Ejecutando directiva: "${prompt}" ${chalk.gray(`(${mission.daily_used}/${mission.daily_limit})`)}`);
-            } else {
-                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;
-
-            // ── Cancelación Manual (Ctrl+C) — Estrategia bulletproof ──
-            // El problema: @clack/prompts registra su propio SIGINT handler cada tick del spinner,
-            // que llama a process.exit(0) directamente. removeAllListeners() no es suficiente porque
-            // Clack lo re-registra en cada frame de animación.
-            //
-            // La solución: interceptar process.exit() antes de que Clack lo llame,
-            // y usar prependListener para que NUESTRO handler siempre se ejecute primero.
-
-            let activeChildProcess = null;
-            let userCanceledMission = false;
-            let sigintCount = 0;
-            let _missionActive = true;  // Mientras true, bloqueamos el process.exit de Clack
-
-            // Guardar el process.exit original y reemplazarlo temporalmente
-            const _origProcessExit = process.exit.bind(process);
-            process.exit = (code) => {
-                if (_missionActive) {
-                    // Clack (u otra lib) está intentando matar el proceso — lo bloqueamos.
-                    // Nuestro cancelHandler ya habrá sido invocado vía prependListener.
-                    // El proceso se cerrará naturalmente cuando el child process termine.
-                    return;
-                }
-                _origProcessExit(code);
-            };
-
-            // ── RESTORE RAW MODE FOR WINDOWS FIX ──
-            // @clack/prompts pausea stdin y desactiva raw mode al terminar un menú.
-            // Debemos reactivarlo aquí para que nuestro interceptor global de Ctrl+C
-            // siga funcionando durante toda la misión.
-            if (process.stdin.isTTY && process.stdin.setRawMode) {
-                try {
-                    process.stdin.setRawMode(true);
-                    process.stdin.resume();
-                } catch(e) {}
-            }
-
-            const cancelHandler = () => {
-                sigintCount++;
-                if (sigintCount > 3) {
-                    console.log(chalk.red('\n🛑 Forzando salida inmediata...'));
-                    _missionActive = false;
-                    _origProcessExit(1);
-                    return;
-                }
-
-                if (userCanceledMission) {
-                    console.log(chalk.yellow('\n⏳ Cancelación en progreso, esperando reporte... (Ctrl+C x4 para forzar cierre)'));
-                    return;
-                }
-                userCanceledMission = true;
-
-                console.log(chalk.yellow('\n\n⚠️  [ARCALITY] Directiva abortada por el operador.'));
-                if (!process.argv.includes('--debug')) {
-                    try { s.stop(chalk.yellow('⚠️  Directiva abortada.')); } catch { /* ignore */ }
-                }
-
-                // Terminar el proceso hijo de Playwright directamente (Windows-safe)
-                if (activeChildProcess && !activeChildProcess.killed) {
-                    try {
-                        if (process.platform === 'win32') {
-                            spawn('taskkill', ['/pid', String(activeChildProcess.pid), '/f', '/t'], { stdio: 'ignore', windowsHide: true });
-                        } else {
-                            activeChildProcess.kill('SIGTERM');
-                        }
-                    } catch { /* silencioso */ }
-                }
-
-                try {
-                    const ctxDir = process.env.CONTEXT_DIR;
-                    if (ctxDir && fs.existsSync(ctxDir)) {
-                        const cancelLog = {
-                            prompt,
-                            history: ['[ABORTO DEL OPERADOR] La directiva fue detenida manualmente antes de completarse.'],
-                            steps: 0,
-                            success: false,
-                            error: true,
-                            fail_reason: 'user_canceled',
-                            canceled_by_user: true,
-                            timestamp: new Date().toISOString()
-                        };
-                        fs.writeFileSync(path.join(ctxDir, `arcality-log-${Date.now()}.json`), JSON.stringify(cancelLog, null, 2));
-                    }
-                } catch { /* silencioso */ }
-
-                console.log(chalk.gray('   >> Esperando que Playwright cierre y genere el reporte...'));
-                // Playwright también recibe el SIGINT nativamente desde la terminal Windows
-                // y cerrará su proceso limpiamente, lo que resolverá la Promise del run() → finally
-            };
-
-            // prependListener asegura que nuestro handler se ejecuta ANTES que el de Clack
-            process.prependListener('SIGINT', cancelHandler);
-            process.prependListener('SIGTERM', cancelHandler);
-
-
-            // Build env for the runner — merge arcality.config values.
-            // ARCALITY_API_URL must be explicit — it comes from the library's internal config,
-            // not from the user's project .env, so we inject it directly via getApiUrl().
-            const fallbackBaseUrl = (!projectConfig && discoverPath?.startsWith('http')) ? discoverPath : undefined;
-
-            const mergedEnv = {
-                ...dotEnv,
-                ...process.env,
-                ARCALITY_API_URL: getApiUrl(),          // Internal URL — always injected explicitly
-                ARCALITY_PROJECT_ID: finalProjectId,
-                ARCALITY_MISSION_ID: mission.mission_id || mission.missionId || mission.MissionId || '',  // ← Propagate mission_id to every proxy call
-                ARCALITY_ORG_ID: validation.organization_id || validation.organizationId || validation.OrganizationId || process.env.ARCALITY_ORG_ID || '',  // ← Propagate org_id for pattern persistence
-                BASE_URL: projectConfig?.project?.baseUrl || dotEnv.BASE_URL || process.env.BASE_URL || fallbackBaseUrl || 'http://localhost:3000',
-                LOGIN_USER: projectConfig?.auth?.username || dotEnv.LOGIN_USER || process.env.LOGIN_USER,
-                LOGIN_PASSWORD: projectConfig?.auth?.password || dotEnv.LOGIN_PASSWORD || process.env.LOGIN_PASSWORD,
-                DOMAIN_DIR: process.env.DOMAIN_DIR,
-                MISSIONS_DIR: process.env.MISSIONS_DIR,
-                CONTEXT_DIR: process.env.CONTEXT_DIR,
-                REPORTS_DIR: process.env.REPORTS_DIR,
-                SMART_PROMPT: prompt,
-                TARGET_PATH: discoverPath || '/'
-            };
-
-            if (finalProjectId) {
-                console.log(chalk.gray(`>> ARCALITY_PROJECT_ID: ${finalProjectId}`));
-                console.log(chalk.gray(`>> ARCALITY_ORG_ID: ${mergedEnv.ARCALITY_ORG_ID || 'NONE'}`));
-            }
-
-            // ── Resolve execution paths ──
-            // tsx and playwright are HOISTED to ORIGINAL_CWD/node_modules when installed via npm.
-            // We run from ORIGINAL_CWD so relative paths for playwright work.
-            // For the test file and config (inside the arcality package), we use absolute paths.
-            //
-            // KEY: tsx loader uses file:// URL (pathToFileURL) so spaces encode as %20 — no quoting needed.
-
-            const testFile = path.join(PROJECT_ROOT, 'tests', '_helpers', 'agentic-runner.spec.ts');
-            const configFile = path.join(PROJECT_ROOT, 'playwright.config.js');
-
-            // Resolve playwright CLI — CRITICAL singleton alignment:
-            //
-            // @playwright/test uses `playwright` internally. When npm detects a version mismatch
-            // between the top-level `playwright` and what `@playwright/test` needs, it installs
-            // a NESTED copy at: @playwright/test/node_modules/playwright/
-            //
-            // Playwright's test runner tracks the active suite via a module-level singleton
-            // (currentSuite). If the CLI uses a DIFFERENT playwright instance than the one
-            // @playwright/test loaded, their singletons are out of sync → "did not expect test()
-            // to be called here".
-            //
-            // Fix: ALWAYS prefer the playwright nested INSIDE @playwright/test, because that is
-            // guaranteed to be the same instance that @playwright/test uses for its internals.
-            //
-            // Resolution priority:
-            //   1. <project>/@playwright/test/node_modules/playwright/cli.js  ← nested (safe)
-            //   2. <project>/playwright/cli.js                                 ← sibling top-level
-            //   (repeated for ORIGINAL_CWD and PROJECT_ROOT)
-            let playwrightCli;
-            try {
-                const searchPaths = [ORIGINAL_CWD, PROJECT_ROOT];
-                let testRunnerPath = null;
-                let resolveError = null;
-
-                for (const searchPath of searchPaths) {
-                    try {
-                        testRunnerPath = require.resolve('@playwright/test', { paths: [searchPath] });
-                        break;
-                    } catch (e) {
-                        resolveError = e;
-                    }
-                }
-
-                if (!testRunnerPath) throw resolveError;
-
-                const testRunnerDir = path.dirname(testRunnerPath); // → .../node_modules/@playwright/test/
-
-                // Priority 1: playwright nested INSIDE @playwright/test — same singleton as the package uses
-                const nestedCli = path.join(testRunnerDir, 'node_modules', 'playwright', 'cli.js');
-                // Priority 2: playwright as a top-level sibling (clean installs, versions aligned)
-                const siblingCli = path.join(testRunnerDir, '..', '..', 'playwright', 'cli.js');
-
-                if (fs.existsSync(nestedCli)) {
-                    playwrightCli = nestedCli;
-                } else if (fs.existsSync(siblingCli)) {
-                    playwrightCli = siblingCli;
-                } else {
-                    throw new Error(
-                        `Playwright CLI not found. Tried:\n  (nested) ${nestedCli}\n  (sibling) ${siblingCli}`
-                    );
-                }
-
-                if (process.argv.includes('--debug')) {
-                    console.log(chalk.gray(`[DEBUG] Using playwright CLI: ${playwrightCli}`));
-                }
-            } catch (e) {
-                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('\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 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.
-                await run('node', [
-                    '--no-warnings',
-                    playwrightCli,
-                    'test',
-                    '--headed',
-                    '--config', 'playwright.config.js'
-                ], {
-                    cwd: PROJECT_ROOT,
-                    env: mergedEnv,
-                    onStatus: (msg) => { if (!process.argv.includes('--debug')) s.message(msg); else console.log(chalk.gray(`>> Status: ${msg}`)); },
-                    onSpawn: (child) => { activeChildProcess = child; }  // ← Capturar referencia para cancelHandler
-                });
-
-                process.removeAllListeners('SIGINT');
-                process.removeAllListeners('SIGTERM');
-                process.on('SIGINT', postProcessSigint);
-                process.on('SIGTERM', postProcessSigint);
-
-                if (userCanceledMission) {
-                    missionResult = 'canceled';
-                    finalFailReason = 'user_canceled';
-                    // Detener el spinner explícitamente antes de salir
-                    if (!process.argv.includes('--debug')) {
-                        try { s.stop(chalk.yellow('⚠️  Misión cancelada por el usuario.')); } catch { }
-                    }
-                    return; // El handler ya tomó el control, finally se ejecutará
-                }
-
-                missionResult = 'success';
-                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);
-
+            if (!prompt || prompt.trim().length < 4) {
+                const p = await text({
+                    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 '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('Misión cancelada. Regresando al menú principal...');
+                    agentMode = false;
+                    prompt = "";
+                    skipMenu = false;
+                    continue;
+                }
+                prompt = p;
+            }
+
+            if (!discoverPath) {
+                const knownBaseUrl = projectConfig?.project?.baseUrl || process.env.BASE_URL;
+                const promptMsg = knownBaseUrl
+                    ? `🌐 URL Completa de Navegación (relative to ${knownBaseUrl}):`
+                    : '🌐 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 'Por favor provee una URL completa con http:// o https://';
+                        return undefined;
+                    }
+                });
+
+                if (isCancel(d)) {
+                    cancel('Misión abortada. Regresando al menú...');
+                    agentMode = false;
+                    prompt = "";
+                    skipMenu = false;
+                    continue;
+                }
+                discoverPath = d;
+            }
+        }
+
+        if (agentMode) {
+            // Load environment from BOTH the user's project and the library's root
+            const userDotEnv = parseDotEnvFile(path.join(ORIGINAL_CWD, '.env'));
+            const libDotEnv = parseDotEnvFile(path.join(PROJECT_ROOT, '.env'));
+            const dotEnv = { ...userDotEnv, ...libDotEnv };
+
+            // ── API Key and Quota Validation ──
+            const { validateApiKey, startMission: requestMission } = await import('../src/arcalityClient.mjs');
+
+            const validation = await validateApiKey();
+            if (process.env.DEBUG || process.argv.includes('--debug')) {
+                console.log(chalk.gray(`[DEBUG] Validation result: ${JSON.stringify(validation, null, 2)}`));
+            }
+            
+            const detectedOrgId = validation.organization_id || validation.organizationId || validation.OrganizationId;
+            if (detectedOrgId) {
+                process.env.ARCALITY_ORG_ID = detectedOrgId;
+            }
+            if (!validation.valid) {
+                const errorMessages = {
+                    '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',
+                    'backend_unavailable': 'No se pudo conectar con Arcality. La herramienta requiere conexion al backend para validar la cuenta.'
+                };
+                note(chalk.red(errorMessages[validation.error] || `Error: ${validation.error}`), '❌ Autenticación');
+                agentMode = false;
+                prompt = "";
+                skipMenu = false;
+                continue;
+            }
+
+            // Show plan info
+            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.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 ---
+            let selectedProjectId = projectConfig?.projectId || dotEnv.ARCALITY_PROJECT_ID || process.env.ARCALITY_PROJECT_ID;
+            const apiBase = getApiUrl();
+
+            if (selectedProjectId && !isRealProjectId(selectedProjectId)) {
+                note(
+                    chalk.red('Project ID invalido: la herramienta no puede ejecutarse con IDs locales o mock.') + '\n' +
+                    chalk.gray('Ejecuta `arcality init` para registrar este proyecto en Arcality.'),
+                    'Proyecto no conectado'
+                );
+                agentMode = false;
+                prompt = "";
+                skipMenu = false;
+                continue;
+            }
+
+            if (!selectedProjectId) {
+                // If no project ID from config, try to create/select from backend
+                try {
+                    const projController = new AbortController();
+                    const projTimeout = setTimeout(() => projController.abort(), 5000);
+                    const projRes = await fetch(`${apiBase}/api/v1/projects`, {
+                        headers: { 'x-api-key': process.env.ARCALITY_API_KEY || '' },
+                        signal: projController.signal
+                    });
+                    clearTimeout(projTimeout);
+
+                    if (projRes.ok) {
+                        const data = await projRes.json();
+                        const projects = data.projects || [];
+
+                        const projOptions = projects.map(p => ({ label: p.name || p.Name, value: p.id || p.Id }));
+                        projOptions.push({ label: '➕ Crear nuevo proyecto', value: 'new' });
+
+                        const projSelection = await select({
+                            message: chalk.cyan('Elige un proyecto para esta misión:'),
+                            options: projOptions
+                        });
+
+                        if (isCancel(projSelection)) {
+                            cancel('Misión abortada.');
+                            agentMode = false; prompt = ""; skipMenu = false; continue;
+                        }
+
+                        if (projSelection === 'new') {
+                            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',
+                                headers: { 'Content-Type': 'application/json', 'x-api-key': process.env.ARCALITY_API_KEY || '' },
+                                body: JSON.stringify({
+                                    name: newName,
+                                    base_url: projectConfig?.project?.baseUrl || discoverPath || '/',
+                                    arcality_version: projectConfig?.meta?.arcalityVersion || 'unknown',
+                                    config: { source: 'npm-cli', single_configuration_mode: true, yaml_reuse_enabled: true }
+                                })
+                            });
+
+                            if (createRes.ok) {
+                                const created = await createRes.json();
+                                selectedProjectId = created.id || created.Id;
+                                if (!isRealProjectId(selectedProjectId)) {
+                                    note(chalk.red('El backend no devolvio un Project ID valido.'), 'Proyecto no conectado');
+                                    selectedProjectId = null;
+                                }
+                                if (selectedProjectId) note(chalk.green(`✅ Proyecto creado: ${newName}`));
+                            } else {
+                                note(chalk.red(`❌ Falló al crear proyecto.`));
+                            }
+                        } else {
+                            selectedProjectId = projSelection;
+                        }
+
+                        if (selectedProjectId) {
+                            process.env.ARCALITY_PROJECT_ID = selectedProjectId;
+                        }
+                    }
+                } catch (e) {
+                    note(
+                        chalk.red(`No se pudo conectar con el servidor de proyectos: ${e.message}`) + '\n' +
+                        chalk.gray('Arcality requiere un proyecto real conectado antes de ejecutar misiones.'),
+                        'Proyecto no conectado'
+                    );
+                }
+            } else {
+                process.env.ARCALITY_PROJECT_ID = selectedProjectId;
+            }
+
+            if (!isRealProjectId(selectedProjectId)) {
+                note(
+                    chalk.red('No hay un Project ID real asignado para esta ejecucion.') + '\n' +
+                    chalk.gray('Ejecuta `arcality init` y vuelve a intentar.'),
+                    'Proyecto no conectado'
+                );
+                agentMode = false;
+                prompt = "";
+                skipMenu = false;
+                continue;
+            }
+
+            // ── Start Mission ──
+            const mission = await requestMission(prompt, discoverPath || '/');
+            if (!mission.allowed) {
+                if (mission.error === 'mission_limit_exceeded') {
+                    note(
+                        chalk.red('Limite diario de misiones alcanzado') + '\n' +
+                        chalk.yellow(`Misiones usadas: ${mission.daily_used}/${mission.daily_limit}`) + '\n' +
+                        chalk.gray(`Reinicio: ${mission.resets_at ? new Date(mission.resets_at).toLocaleString() : 'manana'}`),
+                        'Limite alcanzado'
+                    );
+                } else {
+                    const missionErrors = {
+                        no_project_id: 'No hay Project ID real conectado para esta ejecucion.',
+                        backend_unavailable: 'No se pudo iniciar la mision porque Arcality no respondio.',
+                        server_error: 'Arcality no pudo registrar el inicio de la mision.',
+                        no_api_key: 'API Key no encontrada.'
+                    };
+                    note(
+                        chalk.red(missionErrors[mission.error] || `No se pudo iniciar la mision: ${mission.error}`) + '\n' +
+                        chalk.gray('La prueba no se ejecutara en modo local. Revisa `arcality init` y la conexion al backend.'),
+                        'Mision detenida'
+                    );
+                }
+                agentMode = false;
+                prompt = "";
+                skipMenu = false;
+                continue;
+            }
+
+            const s = spinner();
+            if (!process.argv.includes('--debug')) {
+                s.start(`◉ [ARCALITY INICIADO] Ejecutando directiva: "${prompt}" ${chalk.gray(`(${mission.daily_used}/${mission.daily_limit})`)}`);
+            } else {
+                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;
+
+            // ── Cancelación Manual (Ctrl+C) — Estrategia bulletproof ──
+            // El problema: @clack/prompts registra su propio SIGINT handler cada tick del spinner,
+            // que llama a process.exit(0) directamente. removeAllListeners() no es suficiente porque
+            // Clack lo re-registra en cada frame de animación.
+            //
+            // La solución: interceptar process.exit() antes de que Clack lo llame,
+            // y usar prependListener para que NUESTRO handler siempre se ejecute primero.
+
+            let activeChildProcess = null;
+            let userCanceledMission = false;
+            let sigintCount = 0;
+            let _missionActive = true;  // Mientras true, bloqueamos el process.exit de Clack
+
+            // Guardar el process.exit original y reemplazarlo temporalmente
+            const _origProcessExit = process.exit.bind(process);
+            process.exit = (code) => {
+                if (_missionActive) {
+                    // Clack (u otra lib) está intentando matar el proceso — lo bloqueamos.
+                    // Nuestro cancelHandler ya habrá sido invocado vía prependListener.
+                    // El proceso se cerrará naturalmente cuando el child process termine.
+                    return;
+                }
+                _origProcessExit(code);
+            };
+
+            // ── RESTORE RAW MODE FOR WINDOWS FIX ──
+            // @clack/prompts pausea stdin y desactiva raw mode al terminar un menú.
+            // Debemos reactivarlo aquí para que nuestro interceptor global de Ctrl+C
+            // siga funcionando durante toda la misión.
+            if (process.stdin.isTTY && process.stdin.setRawMode) {
+                try {
+                    process.stdin.setRawMode(true);
+                    process.stdin.resume();
+                } catch(e) {}
+            }
+
+            const cancelHandler = () => {
+                sigintCount++;
+                if (sigintCount > 3) {
+                    console.log(chalk.red('\n🛑 Forzando salida inmediata...'));
+                    _missionActive = false;
+                    _origProcessExit(1);
+                    return;
+                }
+
+                if (userCanceledMission) {
+                    console.log(chalk.yellow('\n⏳ Cancelación en progreso, esperando reporte... (Ctrl+C x4 para forzar cierre)'));
+                    return;
+                }
+                userCanceledMission = true;
+
+                console.log(chalk.yellow('\n\n⚠️  [ARCALITY] Directiva abortada por el operador.'));
+                if (!process.argv.includes('--debug')) {
+                    try { s.stop(chalk.yellow('⚠️  Directiva abortada.')); } catch { /* ignore */ }
+                }
+
+                // Terminar el proceso hijo de Playwright directamente (Windows-safe)
+                if (activeChildProcess && !activeChildProcess.killed) {
+                    try {
+                        if (process.platform === 'win32') {
+                            spawn('taskkill', ['/pid', String(activeChildProcess.pid), '/f', '/t'], { stdio: 'ignore', windowsHide: true });
+                        } else {
+                            activeChildProcess.kill('SIGTERM');
+                        }
+                    } catch { /* silencioso */ }
+                }
+
+                try {
+                    const ctxDir = process.env.CONTEXT_DIR;
+                    if (ctxDir && fs.existsSync(ctxDir)) {
+                        const cancelLog = {
+                            prompt,
+                            history: ['[ABORTO DEL OPERADOR] La directiva fue detenida manualmente antes de completarse.'],
+                            steps: 0,
+                            success: false,
+                            error: true,
+                            fail_reason: 'user_canceled',
+                            canceled_by_user: true,
+                            timestamp: new Date().toISOString()
+                        };
+                        fs.writeFileSync(path.join(ctxDir, `arcality-log-${Date.now()}.json`), JSON.stringify(cancelLog, null, 2));
+                    }
+                } catch { /* silencioso */ }
+
+                console.log(chalk.gray('   >> Esperando que Playwright cierre y genere el reporte...'));
+                // Playwright también recibe el SIGINT nativamente desde la terminal Windows
+                // y cerrará su proceso limpiamente, lo que resolverá la Promise del run() → finally
+            };
+
+            // prependListener asegura que nuestro handler se ejecuta ANTES que el de Clack
+            process.prependListener('SIGINT', cancelHandler);
+            process.prependListener('SIGTERM', cancelHandler);
+
+
+            // Build env for the runner — merge arcality.config values.
+            // ARCALITY_API_URL must be explicit — it comes from the library's internal config,
+            // not from the user's project .env, so we inject it directly via getApiUrl().
+            const fallbackBaseUrl = (!projectConfig && discoverPath?.startsWith('http')) ? discoverPath : undefined;
+
+            const mergedEnv = {
+                ...dotEnv,
+                ...process.env,
+                ARCALITY_API_URL: getApiUrl(),          // Internal URL — always injected explicitly
+                ARCALITY_PROJECT_ID: finalProjectId,
+                ARCALITY_MISSION_ID: mission.mission_id || mission.missionId || mission.MissionId || '',  // ← Propagate mission_id to every proxy call
+                ARCALITY_ORG_ID: validation.organization_id || validation.organizationId || validation.OrganizationId || process.env.ARCALITY_ORG_ID || '',  // ← Propagate org_id for pattern persistence
+                BASE_URL: projectConfig?.project?.baseUrl || dotEnv.BASE_URL || process.env.BASE_URL || fallbackBaseUrl || 'http://localhost:3000',
+                LOGIN_USER: projectConfig?.auth?.username || dotEnv.LOGIN_USER || process.env.LOGIN_USER,
+                LOGIN_PASSWORD: projectConfig?.auth?.password || dotEnv.LOGIN_PASSWORD || process.env.LOGIN_PASSWORD,
+                DOMAIN_DIR: process.env.DOMAIN_DIR,
+                MISSIONS_DIR: process.env.MISSIONS_DIR,
+                CONTEXT_DIR: process.env.CONTEXT_DIR,
+                REPORTS_DIR: process.env.REPORTS_DIR,
+                SMART_PROMPT: prompt,
+                TARGET_PATH: discoverPath || '/'
+            };
+
+            if (finalProjectId) {
+                console.log(chalk.gray(`>> ARCALITY_PROJECT_ID: ${finalProjectId}`));
+                console.log(chalk.gray(`>> ARCALITY_ORG_ID: ${mergedEnv.ARCALITY_ORG_ID || 'NONE'}`));
+            }
+
+            // ── Resolve execution paths ──
+            // tsx and playwright are HOISTED to ORIGINAL_CWD/node_modules when installed via npm.
+            // We run from ORIGINAL_CWD so relative paths for playwright work.
+            // For the test file and config (inside the arcality package), we use absolute paths.
+            //
+            // KEY: tsx loader uses file:// URL (pathToFileURL) so spaces encode as %20 — no quoting needed.
+
+            const testFile = path.join(PROJECT_ROOT, 'tests', '_helpers', 'agentic-runner.spec.ts');
+            const configFile = path.join(PROJECT_ROOT, 'playwright.config.js');
+
+            // Resolve playwright CLI — CRITICAL singleton alignment:
+            //
+            // @playwright/test uses `playwright` internally. When npm detects a version mismatch
+            // between the top-level `playwright` and what `@playwright/test` needs, it installs
+            // a NESTED copy at: @playwright/test/node_modules/playwright/
+            //
+            // Playwright's test runner tracks the active suite via a module-level singleton
+            // (currentSuite). If the CLI uses a DIFFERENT playwright instance than the one
+            // @playwright/test loaded, their singletons are out of sync → "did not expect test()
+            // to be called here".
+            //
+            // Fix: ALWAYS prefer the playwright nested INSIDE @playwright/test, because that is
+            // guaranteed to be the same instance that @playwright/test uses for its internals.
+            //
+            // Resolution priority:
+            //   1. <project>/@playwright/test/node_modules/playwright/cli.js  ← nested (safe)
+            //   2. <project>/playwright/cli.js                                 ← sibling top-level
+            //   (repeated for ORIGINAL_CWD and PROJECT_ROOT)
+            let playwrightCli;
+            try {
+                const searchPaths = [ORIGINAL_CWD, PROJECT_ROOT];
+                let testRunnerPath = null;
+                let resolveError = null;
+
+                for (const searchPath of searchPaths) {
+                    try {
+                        testRunnerPath = require.resolve('@playwright/test', { paths: [searchPath] });
+                        break;
+                    } catch (e) {
+                        resolveError = e;
+                    }
+                }
+
+                if (!testRunnerPath) throw resolveError;
+
+                const testRunnerDir = path.dirname(testRunnerPath); // → .../node_modules/@playwright/test/
+
+                // Priority 1: playwright nested INSIDE @playwright/test — same singleton as the package uses
+                const nestedCli = path.join(testRunnerDir, 'node_modules', 'playwright', 'cli.js');
+                // Priority 2: playwright as a top-level sibling (clean installs, versions aligned)
+                const siblingCli = path.join(testRunnerDir, '..', '..', 'playwright', 'cli.js');
+
+                if (fs.existsSync(nestedCli)) {
+                    playwrightCli = nestedCli;
+                } else if (fs.existsSync(siblingCli)) {
+                    playwrightCli = siblingCli;
+                } else {
+                    throw new Error(
+                        `Playwright CLI not found. Tried:\n  (nested) ${nestedCli}\n  (sibling) ${siblingCli}`
+                    );
+                }
+
+                if (process.argv.includes('--debug')) {
+                    console.log(chalk.gray(`[DEBUG] Using playwright CLI: ${playwrightCli}`));
+                }
+            } catch (e) {
+                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('\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 reporte de telemetría, por favor espera...'));
+            let missionResult = null;
+            let finalFailReason = null;
+            let finalUsageData = undefined;
+            let finalReportUrl = null;
+            let finalFailReasoning = null;
+
+            if (process.env.ARCALITY_RUNNER_PREBUILT === 'true') {
+                if (process.argv.includes('--debug')) {
+                    console.log(chalk.gray('[DEBUG] Runner precompilado por la coleccion. Omitiendo build local.'));
+                }
+            } else
+
+            // ── 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)...'));
+                }
+                await ensureRunnerBundle({ debug: process.argv.includes('--debug') });
+            } 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.
+                await run('node', [
+                    '--no-warnings',
+                    playwrightCli,
+                    'test',
+                    '--headed',
+                    '--config', 'playwright.config.js'
+                ], {
+                    cwd: PROJECT_ROOT,
+                    env: mergedEnv,
+                    onStatus: (msg) => { if (!process.argv.includes('--debug')) s.message(msg); else console.log(chalk.gray(`>> Status: ${msg}`)); },
+                    onSpawn: (child) => { activeChildProcess = child; }  // ← Capturar referencia para cancelHandler
+                });
+
+                process.removeAllListeners('SIGINT');
+                process.removeAllListeners('SIGTERM');
+                process.on('SIGINT', postProcessSigint);
+                process.on('SIGTERM', postProcessSigint);
+
+                if (userCanceledMission) {
+                    missionResult = 'canceled';
+                    finalFailReason = 'user_canceled';
+                    // Detener el spinner explícitamente antes de salir
+                    if (!process.argv.includes('--debug')) {
+                        try { s.stop(chalk.yellow('⚠️  Misión cancelada por el usuario.')); } catch { }
+                    }
+                    return; // El handler ya tomó el control, finally se ejecutará
+                }
+
+                missionResult = 'success';
+                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 ──
                 let saveDecision = 'no';
                 if (!skipSavePrompt && !batchMode) {
@@ -1776,17 +2321,17 @@ async function main() {
                 }
 
                 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
-                    });
-
+                    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();
-
-                        // Save to missions dir (existing flow)
-                        const missionsDir = process.env.MISSIONS_DIR;
+
+                        // Save to missions dir (existing flow)
+                        const missionsDir = process.env.MISSIONS_DIR;
                         const missionSaveDir = await selectMissionSaveDir(missionsDir);
                         if (!missionSaveDir) {
                             note(chalk.yellow('Guardado de mision cancelado.'), 'Persistencia Arcality');
@@ -1807,8 +2352,8 @@ async function main() {
                             `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');
+
+                        const smartYamlPath = path.join(process.env.CONTEXT_DIR, 'last-mission-smart.yaml');
                         if (fs.existsSync(smartYamlPath)) {
                             const smartYamlContent = fs.readFileSync(smartYamlPath, 'utf8').trim();
                             yamlData = [
@@ -1823,172 +2368,175 @@ async function main() {
                                 smartYamlContent
                             ].join('\n') + '\n';
                         }
-
-                        // Internal fallback backup for the agent
-                        fs.writeFileSync(yamlPathMissions, yamlData);
-
-                        // Primary save to user's specified directory from arcality.config
-                        if (projectConfig) {
-                            const yamlOutputDir = ensureYamlOutputDir(projectConfig, ORIGINAL_CWD);
+
+                        // Internal fallback backup for the agent
+                        fs.writeFileSync(yamlPathMissions, yamlData);
+
+                        // Primary save to user's specified directory from arcality.config
+                        if (projectConfig) {
+                            const yamlOutputDir = ensureYamlOutputDir(projectConfig, ORIGINAL_CWD);
                             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 {
-                            note(chalk.green(`✅ Misión guardada en: ${yamlPathMissions}`), 'Persistencia Arcality');
-                        }
-                    }
-                }
-            } catch (e) {
-                // SIGINT ya fue manejado por cancelHandler — solo clasificamos el resultado
-                if (userCanceledMission) {
-                    missionResult = 'canceled';
-                    finalFailReason = 'user_canceled';
-                    console.log(chalk.yellow('\n⚠️  Directiva abortada — generando reporte de evidencia...'));
-                } else {
-                    missionResult = 'failed';
-                    finalFailReason = 'timeout_or_crash';
-                    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));
-                    }
-                }
-            } finally {
-                // Desactivar el bloqueo de process.exit y restaurar el original
-                _missionActive = false;
-                process.exit = _origProcessExit;
-                process.removeListener('SIGINT', cancelHandler);
-                process.removeListener('SIGTERM', cancelHandler);
-
-                if (userCanceledMission) {
-                    missionResult = 'canceled';
-                    finalFailReason = 'user_canceled';
-                    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));
-                }
-
-                process.on('SIGINT', postProcessSigint);
-                process.on('SIGTERM', postProcessSigint);
-
-                const sRep = spinner();
-                if (!process.argv.includes('--debug')) {
-                    sRep.start('📊 Generando reporte...');
-                } else {
-                    console.log('📊 Generando reporte...');
-                }
-
-                await run("node", [path.join(PROJECT_ROOT, "scripts/rebrand-report.mjs")]).catch(() => { });
-
-                const reportDir = process.env.REPORTS_DIR || 'tests-report';
-                const arcalityPath = path.resolve(reportDir, 'index.html');
-
-                sRep.stop();
-
-                // Read final usage and failReason from agent-log
-                try {
-                    const ctxDir = process.env.CONTEXT_DIR;
-                    if (fs.existsSync(ctxDir)) {
+                            fs.writeFileSync(yamlPathOutput, yamlData);
+                            note(chalk.green(`✅ Misión guardada en: ${yamlPathOutput}`), 'Persistencia Arcality');
+                        } else {
+                            note(chalk.green(`✅ Misión guardada en: ${yamlPathMissions}`), 'Persistencia Arcality');
+                        }
+                    }
+                }
+            } catch (e) {
+                // SIGINT ya fue manejado por cancelHandler — solo clasificamos el resultado
+                if (userCanceledMission) {
+                    missionResult = 'canceled';
+                    finalFailReason = 'user_canceled';
+                    console.log(chalk.yellow('\n⚠️  Directiva abortada — generando reporte de evidencia...'));
+                } else {
+                    missionResult = 'failed';
+                    finalFailReason = 'timeout_or_crash';
+                    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));
+                    }
+                }
+            } finally {
+                // Desactivar el bloqueo de process.exit y restaurar el original
+                _missionActive = false;
+                process.exit = _origProcessExit;
+                process.removeListener('SIGINT', cancelHandler);
+                process.removeListener('SIGTERM', cancelHandler);
+
+                if (userCanceledMission) {
+                    missionResult = 'canceled';
+                    finalFailReason = 'user_canceled';
+                    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));
+                }
+
+                process.on('SIGINT', postProcessSigint);
+                process.on('SIGTERM', postProcessSigint);
+
+                const sRep = spinner();
+                if (!process.argv.includes('--debug')) {
+                    sRep.start('📊 Generando reporte...');
+                } else {
+                    console.log('📊 Generando reporte...');
+                }
+
+                await run("node", [path.join(PROJECT_ROOT, "scripts/rebrand-report.mjs")]).catch(() => { });
+
+                const reportDir = process.env.REPORTS_DIR || 'tests-report';
+                const arcalityPath = path.resolve(reportDir, 'index.html');
+
+                sRep.stop();
+
+                // Read final usage and failReason from agent-log
+                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.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'));
-                            finalUsageData = logData.usage || finalUsageData;
-                            finalFailReasoning = logData.fail_reasoning || null;
-                            if (missionResult === 'failed' && !finalFailReason) {
-                                finalFailReason = logData.fail_reason || "timeout_or_crash";
-                            }
-                        }
-                    }
-                } catch(e) {}
-
-                // ── Upload Evidence (solo si NO fue cancelado por usuario) ──
-                if (missionResult !== 'canceled') {
-                    try {
-                        const { getEvidenceSasToken } = await import('../src/arcalityClient.mjs');
-                        const { uploadEvidence } = await import('../src/EvidenceUploader.mjs');
-
-                        const sasData = await getEvidenceSasToken(mission.mission_id, finalProjectId);
-                        if (process.argv.includes('--debug')) console.log(`[DEBUG] sasData received:`, sasData);
-
-                        const actualSasUrl = sasData?.sasTokenUrl || sasData?.sasUrl || sasData?.sas_url;
-                        const actualBasePath = sasData?.basePath || sasData?.base_path;
-
-                        if (sasData && actualSasUrl && actualBasePath) {
-                            if (!process.argv.includes('--debug')) {
-                                sRep.start('☁️  Subiendo evidencia a Azure...');
-                            }
-                            process.removeAllListeners('SIGINT');
-                            process.removeAllListeners('SIGTERM');
-                            process.on('SIGINT', postProcessSigint);
-                            process.on('SIGTERM', postProcessSigint);
-
-                            await uploadEvidence(reportDir, actualSasUrl, actualBasePath);
-
-                            try {
-                                const parsedSas = new URL(actualSasUrl);
-                                finalReportUrl = `${parsedSas.origin}${parsedSas.pathname}/${actualBasePath}/index.html`;
-                            } catch(e) {}
-
-                            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('⚠️  Fallo al subir evidencia.'));
-                    }
-                } else {
-                    console.log(chalk.gray('   >> Saltando subida de evidencia (la misión fue cancelada).'));
-                }
-
-                // ── End Mission — SIEMPRE se llama, independientemente de si la evidencia subió ──
-                try {
-                    const { endMission } = await import('../src/arcalityClient.mjs');
-                    await endMission(mission.mission_id, missionResult || 'failed', finalUsageData, finalFailReason, finalReportUrl, finalFailReasoning);
-                    if (process.argv.includes('--debug')) console.log(chalk.gray(`[DEBUG] endMission called → result: ${missionResult}, failReason: ${finalFailReason}`));
-                } catch (e) {
-                    if (process.argv.includes('--debug')) console.log(chalk.yellow(`⚠️  Could not end mission in backend: ${e.message}`));
-                }
-
-                if (globalReportProcess) {
-                    try {
-                        if (process.platform === "win32") {
-                            spawn("taskkill", ["/pid", globalReportProcess.pid, "/f", "/t"], { stdio: 'ignore', windowsHide: true });
-                        } else {
-                            globalReportProcess.kill();
-                        }
-                    } catch (e) { /* ignore */ }
-                    globalReportProcess = null;
-                }
-
+                        if (logFiles.length > 0) {
+                            const lastLog = path.join(ctxDir, logFiles[logFiles.length - 1]);
+                            const logData = JSON.parse(fs.readFileSync(lastLog, 'utf8'));
+                            finalUsageData = logData.usage || finalUsageData;
+                            finalFailReasoning = logData.fail_reasoning || null;
+                            if (missionResult === 'failed' && !finalFailReason) {
+                                finalFailReason = logData.fail_reason || "timeout_or_crash";
+                            }
+                        }
+                    }
+                } catch(e) {}
+
+                // ── Upload Evidence (solo si NO fue cancelado por usuario) ──
+                if (missionResult !== 'canceled') {
+                    try {
+                        const { getEvidenceSasToken } = await import('../src/arcalityClient.mjs');
+                        const { uploadEvidence } = await import('../src/EvidenceUploader.mjs');
+
+                        const sasData = await getEvidenceSasToken(mission.mission_id, finalProjectId);
+                        if (process.argv.includes('--debug')) console.log(`[DEBUG] sasData received:`, sasData);
+
+                        const actualSasUrl = sasData?.sasTokenUrl || sasData?.sasUrl || sasData?.sas_url;
+                        const actualBasePath = sasData?.basePath || sasData?.base_path;
+
+                        if (sasData && actualSasUrl && actualBasePath) {
+                            if (!process.argv.includes('--debug')) {
+                                sRep.start('☁️  Subiendo evidencia a Azure...');
+                            }
+                            process.removeAllListeners('SIGINT');
+                            process.removeAllListeners('SIGTERM');
+                            process.on('SIGINT', postProcessSigint);
+                            process.on('SIGTERM', postProcessSigint);
+
+                            await uploadEvidence(reportDir, actualSasUrl, actualBasePath);
+
+                            try {
+                                const parsedSas = new URL(actualSasUrl);
+                                finalReportUrl = `${parsedSas.origin}${parsedSas.pathname}/${actualBasePath}/index.html`;
+                            } catch(e) {}
+
+                            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('⚠️  Fallo al subir evidencia.'));
+                    }
+                } else {
+                    console.log(chalk.gray('   >> Saltando subida de evidencia (la misión fue cancelada).'));
+                }
+
+                // ── End Mission — SIEMPRE se llama, independientemente de si la evidencia subió ──
+                try {
+                    const { endMission } = await import('../src/arcalityClient.mjs');
+                    await endMission(mission.mission_id, missionResult || 'failed', finalUsageData, finalFailReason, finalReportUrl, finalFailReasoning);
+                    if (process.argv.includes('--debug')) console.log(chalk.gray(`[DEBUG] endMission called → result: ${missionResult}, failReason: ${finalFailReason}`));
+                } catch (e) {
+                    if (process.argv.includes('--debug')) console.log(chalk.yellow(`⚠️  Could not end mission in backend: ${e.message}`));
+                }
+
+                if (globalReportProcess) {
+                    try {
+                        if (process.platform === "win32") {
+                            spawn("taskkill", ["/pid", globalReportProcess.pid, "/f", "/t"], { stdio: 'ignore', windowsHide: true });
+                        } else {
+                            globalReportProcess.kill();
+                        }
+                    } catch (e) { /* ignore */ }
+                    globalReportProcess = null;
+                }
+
                 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}"`);
-                    }
+                    openLocalFile(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));
-
-                // Ping project after report
-                await pingProject(
-                    process.env.ARCALITY_PROJECT_ID,
-                    process.env.ARCALITY_API_KEY
-                );
-
-                // Limpiar handlers del post-proceso ANTES de esperar Enter, ya que toda la telemetría y reportes ya finalizaron
-                process.removeListener('SIGINT', postProcessSigint);
-                process.removeListener('SIGTERM', postProcessSigint);
-
+
+                await new Promise(resolve => setTimeout(resolve, 2000));
+
+                // Ping project after report
+                await pingProject(
+                    process.env.ARCALITY_PROJECT_ID,
+                    process.env.ARCALITY_API_KEY
+                );
+
+                // Limpiar handlers del post-proceso ANTES de esperar Enter, ya que toda la telemetría y reportes ya finalizaron
+                process.removeListener('SIGINT', postProcessSigint);
+                process.removeListener('SIGTERM', postProcessSigint);
+
                 if (!batchMode) {
+                    await waitForEnter('Presiona Enter para regresar al menu...', {
+                        pauseOnResolve: skipMenu,
+                        restoreRawMode: !skipMenu
+                    });
+                }
+
+                if (false && !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.
@@ -2030,22 +2578,22 @@ async function main() {
                         process.stdin.on('data', onKey);
                     });
                 }
-
-                if (skipMenu) {
-                    outro(chalk.cyan('¡Misión terminada! Hasta luego.'));
-                    return;
-                }
-
-                agentMode = false;
-                prompt = "";
-                firstRun = false;
-            }
-        }
-        firstRun = false;
-    }
-}
-
-main().catch(err => {
-    console.error(err);
-    process.exit(1);
-});
+
+                if (skipMenu) {
+                    outro(chalk.cyan('¡Misión terminada! Hasta luego.'));
+                    return;
+                }
+
+                agentMode = false;
+                prompt = "";
+                firstRun = false;
+            }
+        }
+        firstRun = false;
+    }
+}
+
+main().catch(err => {
+    console.error(err);
+    process.exit(1);
+});