mcp-state-machine-test-framework 1.2.3 → 1.2.7

package/README.md

@@ -1,60 +1,31 @@
-# 🚀 MCP State Machine Test Framework (SMS)
-
-The high-fidelity, autonomous orchestration engine for Next-Generation E2E Testing.
-
-## 🌟 Key Features
-- **Pure-MCP Architecture**: 100% compliant with the Model Context Protocol for seamless AI agent integration.
-- **Universal**: Supports Web, Mobile, and API testing through modular MCP tool aggregation.
-- **Secure by Design**: Automatic masking of sensitive data (tokens, JWTs) in reports and logs.
-- **Premium Reporting**: Generates high-fidelity HTML/JSON dashboards with glassmorphism aesthetics.
-- **Data-Driven Core**: Native support for complex testing scenarios via CSV and JSON data injection.
-
-## 🛠️ Quick Installation
-
-You can install it as a dependency in your project:
-
-```bash
-npm install mcp-state-machine-test-framework
-```
-
-Or run it directly via MCP in your configuration:
-
-```json
-"mcp-sms": {
-  "command": "npx",
-  "args": ["mcp-state-machine-test-framework"]
-}
-```
-
-## 🏁 Basic Workflow
-1. **Initialize Project**: Run `init_project` to setup folders and templates.
-2. **Guided Design**: Tell the agent to "Create a new node". The agent will ask for the mandatory fields (Map, Node Name, Transitions) before executing.
-3. **Automatic Visualization**: Every map change regenerates a Mermaid diagram in `/maps`.
-4. **Execution**: Run `execute_suite` to launch the automated flow.
-
-## 🤖 AI Agent Interaction (Guided Design)
-This framework enforces a "Strict Contract" via MCP tools. Agents are instructed NOT to edit JSON files directly, but to use the management tools (`upsert_node`, `save_test_case`, `save_suite`) which provide validation and structure.
-
-## 📚 Technical Documentation
-- [🧠 Technical Protocol & History](./SMS_Protocol.md)
-- [📱 Perfecto Mobile Cloud Setup](./DOCUMENTATION/Perfecto_Setup.md)
-- [🤖 Agent Guidelines](./agent_protocol.md)
-
-## 🤖 AI Agent Quickstart (For Copilot/Cursor/Antigravity)
-If you are an AI agent helping with this project, follow these rules:
-1. **Environment**: This is a Node.js project. Always use `npm`.
-2. **Setup**: Install via `npm install mcp-state-machine-test-framework`.
-3. **Configuration**: Use `npx mcp-sms` as the command in `mcp_config.json`.
-4. **Initialization**: Your very first action after installation **MUST** be calling the `init_project` tool to create the directory structure and templates.
-5. **Workflow**: Use `inspect_framework` to understand the current state before proposing changes.
-
-## 🚀 Mission Bootstrap (Copy & Paste to any AI Agent)
-> **YOUR ONLY MISSION**: 
-> 1. Run `npx -y -p mcp-state-machine-test-framework mcp-sms-init` to setup EVERYTHING.
-> 2. Use `design_wizard` (action: 'start') to design nodes step-by-step.
-> 3. **STRICT RULE**: Never edit JSON files manually.
-> 
-> "Run `npx -y -p mcp-state-machine-test-framework mcp-sms-init`. Then start a design session using `design_wizard` (action: 'start'). Follow the wizard steps to create nodes and transitions."
+# 🚀 SMS Framework: State Machine Testing V12.0
+
+> **Orquestación de Pruebas E2E de Alta Fidelidad mediante Máquina de Estados Procedural.**
+
+Este framework transforma la automatización tradicional en un sistema de orquestación autónomo donde la **Identidad de los Nodos** y la **Verificación Técnica** garantizan pruebas irrompibles en Web, Mobile y API.
+
+## 🌟 Características Principales
+
+*   **🛡️ Identidad Multivectorial (Fingerprinting)**: Los nodos no son solo nombres; tienen una huella digital (múltiples selectores) que el motor valida automáticamente para asegurar la sincronización total entre el mapa y la realidad.
+*   **⚙️ Ejecución Híbrida (MCP + SH)**: Soporte nativo para comandos de cualquier servidor MCP y comandos de Shell (`sh:`) en un mismo flujo.
+*   **🧪 Asserts Técnicos por Paso**: Cada paso del test puede incluir validaciones profundas (DB, API, Logs) mediante el campo `assert`.
+*   **🧙‍♂️ Wizards Integrados**: Asistentes guiados (`design_wizard` y `test_wizard`) para construir mapas y pruebas sin errores de sintaxis.
+*   **📊 Dashboard Premium**: Reportes HTML con glassmorphism que distinguen visualmente entre acciones, validaciones de identidad y asserts.
+
+## 🚀 Inicio Rápido
+
+1.  **Instalación**: `npm install`
+2.  **Inicialización**: Usa el comando `init_project` para generar la estructura de carpetas.
+3.  **Diseño**: Usa `design_wizard` para crear tu primer mapa con identidad protegida.
+4.  **Prueba**: Usa `test_wizard` para ensamblar tu flujo de prueba.
+5.  **Ejecución**: `ejecutarSuite(suiteName)`
+
+## 📁 Estructura del Proyecto
+
+*   `/maps`: Definiciones de la Máquina de Estados (Nodos, Fingerprints, Transiciones).
+*   `/test_cases`: Pasos lógicos de prueba con acciones y asserts.
+*   `/suites`: El pegamento que une mapas, pruebas y hooks globales.
+*   `/reports`: Evidencia técnica y visual con alta fidelidad.
 
 ---
-*Developed with ❤️ for maximum automation efficiency.*
+*Desarrollado para la era de la automatización autónoma.*

package/SMS_Protocol.md

@@ -1,49 +1,47 @@
-# 🧠 Historial Técnico y Protocolo: SMS MCP Server
-
-Este documento registra el aprendizaje evolutivo sobre el uso del **State Machine Server (SMS)** y su integración con otros servidores MCP (ej. `wdio-mcp`). **No contiene lógica de negocio**, sino maestría técnica.
-
-## 🛠️ Integración con WDIO-MCP (Aprendizajes Clave)
-
-### 1. Gestión de Capacidades (Mobile Cloud)
-- **Timeouts**: En entornos cloud (Perfecto), las sesiones tardan en inicializarse. Es vital usar `timeout: 30000` en acciones críticas de navegación.
-- **Capabilities Estables**: Para Android en Perfecto, el set mínimo estable es:
-    - `automationName: "UiAutomator2"`
-    - `useVirtualDevice: true`
-    - `app: "PRIVATE:NombreDeLaApp.apk"`
-- **Ciclo de Sesión**: Es preferible cerrar y abrir sesiones entre suites independientes para evitar colisiones de estado en el driver.
-
-### 2. Estrategias de Selectores en MCP
-- **Prioridad de Accesibilidad**: Siempre intentar primero `~ID_Accesibilidad`. Es el método más rápido y compatible con MCP.
-- **XPaths Robustos**: Cuando no hay IDs, usar `//*[@resource-id='com.id.app:id/elemento']//android.widget.EditText`. La doble barra `//` ayuda a mitigar cambios menores en la jerarquía.
-- **Scroll Automático**: Para elementos fuera de vista, usar el selector nativo de Android: `android=new UiScrollable(new UiSelector().scrollable(true)).scrollIntoView(new UiSelector().resourceId("..."))`.
-
-### 3. Autenticación y Credenciales
-- **Estrategia de Descubrimiento**: Si las variables de entorno están vacías, rastrear archivos de "scratch" o scripts de verificación (`verify_*.js`) donde el usuario suele dejar tokens hardcodeados para pruebas rápidas.
-- **Formato Perfecto**: El token debe inyectarse en `perfecto:options` -> `securityToken`.
-
-## ⚙️ Arquitectura del Servidor SMS
-
-### 1. Protocolo de Comunicación "Pure MCP"
-- **STDOUT Protegido**: Nunca usar `console.log` para depuración. Cualquier salida no-JSON rompe la conexión. Usar `process.stderr.write` o volcar a un archivo de log externo.
-- **Resolución de Rutas**: Los servidores MCP se lanzan desde contextos variables. Siempre usar `path.join(__dirname, ...)` para localizar mapas, casos y suites.
-
-### 2. Motor de Reportes y Evidencia
-- **Agregación de Resultados**: El servidor SMS itera sobre el array `content` de las respuestas MCP. Captura automáticamente:
-    - `type: "image"` -> Se convierte en miniatura visual.
-    - `type: "text"` -> Se guarda como log técnico expandible.
-- **Interpolación Dinámica**: Soporte para `{{variable}}` en las acciones, permitiendo inyectar datos de archivos CSV/JSON en tiempo de ejecución.
-
-## 🔄 Formatos de Ejecución
-- **Tool Principal**: `execute_suite({ "name": "Nombre_Suite" })`.
-- **Estructura Modular**: Suite -> Test Cases -> Steps -> Actions. Esta jerarquía garantiza que los reportes sean legibles y la evidencia se asocie correctamente a cada paso lógico.
-
-## 🛠️ Herramientas de Gestión (Management Tools)
-
-A partir de la versión 1.0.1, el servidor incluye herramientas para la construcción estructurada del framework:
-
-- **`upsert_node`**: Garantiza la integridad del mapa de estados. Valida que cada nodo tenga sus transiciones correctamente definidas.
-- **`save_test_case`**: Normaliza la creación de pasos de prueba, asegurando que la jerarquía Suite -> Case -> Step se mantenga para el generador de reportes.
-- **`save_suite`**: Orquesta el ensamblaje final, permitiendo la inyección de hooks (`before/afterSuite`) que son críticos para la gestión de sesiones en la nube.
+# 📑 SMS Protocol: Referencia Técnica V12.0
+
+Este documento detalla los esquemas de datos para la orquestación de la Máquina de Estados.
+
+## 🗺️ Esquema del Mapa (`/maps/*.json`)
+
+### Estructura de Nodo
+```json
+"NOMBRE_NODO": {
+  "fingerprint": {
+    "selectors": ["~logo", "id:main_container"],
+    "timeout": 5000
+  },
+  "transiciones": {
+    "NOMBRE_TRANSICION": {
+      "destino": "OTRO_NODO",
+      "accion": "mcp:wdio-mcp/click_element { \"selector\": \"~btn\" }"
+    }
+  }
+}
+```
+
+## 🧪 Esquema del Test Case (`/test_cases/*.json`)
+
+### Estructura de Paso
+```json
+{
+  "name": "TC_Ejemplo",
+  "steps": [
+    {
+      "name": "Paso 1",
+      "action": "TRANSICION_O_COMANDO",
+      "assert": "mcp:wdio-mcp/wait_for_element { \"selector\": \"~success_icon\" }"
+    }
+  ]
+}
+```
+
+## ⚙️ Lógica del Motor de Ejecución
+
+1.  **Resolución de Acción**: Si la acción empieza por `transicion:`, el motor busca en el mapa cargado.
+2.  **Ejecución Principal**: Corre la acción (MCP o SH).
+3.  **Check de Identidad**: Si el destino tiene `fingerprint`, el motor itera por todos sus `selectors` y valida su presencia.
+4.  **Check de Assert**: Si el paso tiene `assert`, se ejecuta como una validación final antes de marcar el paso como "Passed".
 
 ---
-*Documento en evolución constante. Agregue nuevos aprendizajes técnicos aquí.*
+*Nota: Todos los campos de texto dentro de las acciones y asserts soportan interpolación de datos dinámicos mediante `{{campo}}`.*

package/agent_protocol.md

@@ -1,24 +1,34 @@
-# 🤖 Protocolo de Operación del Agente: SMS Framework
+# 🤖 Protocolo de Operación del Agente: SMS Framework V12.0
 
-Este protocolo es de **obligado cumplimiento** para cualquier agente que opere el MCP State Machine Test Framework.
+Este protocolo es de **obligado cumplimiento** para asegurar la integridad de la Máquina de Estados y la calidad de los reportes.
 
-## ⚖️ Reglas de Construcción de Pruebas
+## 🛠️ Herramientas de Gestión (MANDATORIO)
 
-### 1. Gestión de Mapas y Estados
-- **PROHIBIDO**: Crear o editar archivos en `/maps` usando herramientas genéricas de escritura de archivos.
-- **MANDATORIO**: Usar la herramienta `upsert_node` para añadir o modificar nodos. Esto asegura que la estructura de transiciones y acciones sea válida para el motor de ejecución.
+Los agentes **NO** deben crear archivos JSON manualmente si existe un Wizard disponible:
 
-### 2. Definición de Casos de Prueba
-- **MANDATORIO**: Usar `save_test_case`. El agente debe definir los `steps` como un array de objetos, asegurando que cada paso tenga un nombre descriptivo para el reporte final.
+1.  **Diseño de Mapas**: Usar `design_wizard`.
+    *   Cada nodo **DEBE** tener una `fingerprint` (huella digital).
+    *   Se recomienda usar **Múltiples Selectores** (Multivectorial) para evitar ambigüedades entre pantallas similares.
+2.  **Creación de Pruebas**: Usar `test_wizard`.
+    *   Definir un `assert` técnico en pasos críticos (Login, Submit, Delete).
+    *   Usar el prefijo `sh:` para validaciones de sistema/archivos y `mcp:` para validaciones de UI.
 
-### 3. Ensamblaje de Suites
-- **MANDATORIO**: Usar `save_suite`. El agente debe verificar que el `state_map` referenciado exista antes de guardar la suite.
+## ⚖️ Reglas de Oro
 
-## 🔄 Flujo de Trabajo Autónomo (Discovery-to-Code)
-1. **Explorar**: Usar `wdio-mcp/get_elements` para identificar selectores.
-2. **Registrar**: Inmediatamente usar `upsert_node` para añadir el hallazgo al mapa de estados.
-3. **Validar**: Ejecutar un `save_test_case` rápido para confirmar que la nueva transición funciona.
-4. **Reportar**: Usar `execute_suite` para generar la evidencia visual del nuevo flujo descubierto.
+### 1. Sincronización de Identidad
+El agente debe asegurar que el `selector` usado en la `fingerprint` de un nodo sea visible de forma persistente mientras se está en esa pantalla. Si una pantalla es dinámica, usar el elemento más estable como "ancla".
 
----
-*V1.1 - Protocolo de Integridad Estructural*
+### 2. Validaciones (Asserts)
+*   **Acción**: Lo que el agente hace para mover la app.
+*   **Assert**: Lo que el agente verifica para confirmar el éxito del negocio.
+*   *Nota*: El motor fallará el paso si el `assert` devuelve un error, capturando automáticamente la evidencia en ese punto.
+
+### 3. Prefijos de Acción
+*   `transicion:NOMBRE`: Ejecuta una ruta definida en el mapa.
+*   `mcp:SERVIDOR/HERRAMIENTA {args}`: Ejecución directa de herramienta.
+*   `sh:COMANDO`: Ejecución directa en consola del host.
+
+## 📊 Reportes y Diagnóstico
+Si una suite falla, el agente debe revisar el Dashboard:
+*   Si el error es de **Identidad**: El mapa o el selector de la huella están desactualizados.
+*   Si el error es de **Assert**: La funcionalidad de la aplicación bajo prueba ha fallado.

package/index.js

@@ -12,16 +12,9 @@ import { exec } from "child_process";
 import { promisify } from "util";
 
 const execAsync = promisify(exec);
-
-async function log(msg) {
-    const time = new Date().toISOString();
-    const line = `[${time}] ${msg}\n`;
-    await fs.appendFile("sms_server.log", line);
-}
-
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
-const DB_FILE = path.join(__dirname, "maquina_db.json");
+
 const SUITES_DIR = path.join(__dirname, "suites");
 const CASOS_DIR = path.join(__dirname, "test_cases");
 const REPORTS_ROOT = path.join(__dirname, "reports");
@@ -53,13 +46,12 @@ export class MaquinaDeEstados {
         if (this.mcpClients.has(serverName)) return this.mcpClients.get(serverName);
         const configRaw = await fs.readFile(CONFIG_FILE, "utf-8");
         const config = JSON.parse(configRaw).mcpServers[serverName];
-        if (!config) throw new Error(`Configuración no encontrada para ${serverName}`);
         const transport = new StdioClientTransport({
             command: config.command,
             args: config.args || [],
             env: { ...process.env, ...config.env }
         });
-        const client = new Client({ name: "SMS-Client", version: "11.1.0" }, { capabilities: {} });
+        const client = new Client({ name: "SMS-Client", version: "12.5.0" }, { capabilities: {} });
         await client.connect(transport);
         const data = { client, transport };
         this.mcpClients.set(serverName, data);
@@ -69,156 +61,81 @@ export class MaquinaDeEstados {
     interpolate(text, data) {
         if (!data) return text;
         let result = text;
-        for (const key in data) {
-            result = result.replace(new RegExp(`{{${key}}}`, 'g'), data[key]);
-        }
+        for (const key in data) { result = result.replace(new RegExp(`{{${key}}}`, 'g'), data[key]); }
         return result;
     }
 
-    async loadExternalData(dataPath) {
-        const fullPath = path.isAbsolute(dataPath) ? dataPath : path.join(__dirname, dataPath);
-        if (!fsSync.existsSync(fullPath)) return null;
-
-        const content = await fs.readFile(fullPath, "utf-8");
-        if (fullPath.endsWith(".json")) return JSON.parse(content);
-
-        if (fullPath.endsWith(".csv")) {
-            const lines = content.split("\n").map(l => l.trim()).filter(l => l.length > 0);
-            if (lines.length < 2) return [];
-            const headers = lines[0].split(",").map(h => h.trim().replace(/^["']|["']$/g, ""));
-            return lines.slice(1).map(line => {
-                const values = line.split(",");
-                const obj = {};
-                headers.forEach((h, i) => {
-                    let val = values[i] ? values[i].trim() : "";
-                    // Quitar comillas si existen
-                    val = val.replace(/^["']|["']$/g, "");
-                    obj[h] = val;
-                });
-                return obj;
-            });
-        }
-        return null;
-    }
-
     async ejecutarSuite(suiteName) {
         const suite = this.suites.get(suiteName);
         if (!suite) throw new Error(`Suite '${suiteName}' no encontrada.`);
-
-        if (suite.state_map) {
-            process.stderr.write(`\n📍 [V12.3] Pre-flight Integrity Check for: ${suite.state_map}\n`);
-            // Simplified validation: Ensure the file exists and has the required structure
-            const mapPath = path.join(__dirname, 'maps', suite.state_map);
-            try {
-                await fs.access(mapPath);
-                const mapData = JSON.parse(await fs.readFile(mapPath, 'utf8'));
-                const nodes = mapData.nodos || mapData;
-                process.stderr.write(`✅ Map validated (${Object.keys(nodes).length} nodes found).\n`);
-            } catch (e) {
-                process.stderr.write(`❌ CRITICAL: State Map '${suite.state_map}' not found or invalid!\n`);
-                throw new Error(`Integrity Check Failed: ${e.message}`);
-            }
-        }
-
+        
         const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
         const reportDir = path.join(REPORTS_ROOT, `exec_${suiteName}_${timestamp}`);
         await fs.mkdir(reportDir, { recursive: true });
         const results = { suiteName, timestamp, cases: [], hooks: { beforeSuite: [], afterSuite: [] } };
 
-        const maskSecrets = (text) => {
-            if (typeof text !== "string") return text;
-            // Enmascarar tokens de seguridad y JWTs
-            return text.replace(/("securityToken"\s*:\s*")[^"]+(")/g, '$1********$2')
-                .replace(/("token"\s*:\s*")[^"]+(")/g, '$1********$2')
-                .replace(/eyJhbGciOi[A-Za-z0-9-_=]+\.[A-Za-z0-9-_=]+\.?[A-Za-z0-9-_.+/=]*/g, '********[JWT_MASKED]********');
-        };
-
         const runActions = async (actions, targetRes, data) => {
             if (!actions) return;
             for (const action of actions) {
-                const maskedAction = maskSecrets(action);
-                process.stderr.write(`[EXEC] Running action: ${maskedAction}\n`);
-                const actionRes = { action: maskedAction, status: "passed" };
+                const actionRes = { action, status: "passed" };
                 targetRes.push(actionRes);
                 try {
-                    let lastResult = null;
                     const executeAction = async (act) => {
                         const subRes = (act === action) ? actionRes : { action: act, status: "passed" };
                         if (act !== action) targetRes.push(subRes);
-
-                        let finalAction = act;
-                        try {
-                            if (act.startsWith("transicion:")) {
-                                const transName = act.replace("transicion:", "").trim();
-                                const mapPath = path.join(__dirname, 'maps', suite.state_map);
-                                const mapData = JSON.parse(await fs.readFile(mapPath, 'utf8'));
-                                const nodes = mapData.nodos || mapData;
-
-                                let foundAction = null;
-                                for (const node of Object.values(nodes)) {
-                                    if (node.transiciones && node.transiciones[transName]) {
-                                        foundAction = node.transiciones[transName].accion;
-                                        break;
-                                    }
+                        
+                        if (act.startsWith("transicion:")) {
+                            const transName = act.replace("transicion:", "").trim();
+                            const mapPath = path.join(__dirname, 'maps', suite.state_map);
+                            const mapData = JSON.parse(await fs.readFile(mapPath, 'utf8'));
+                            const nodes = mapData.nodos || mapData;
+                            
+                            let foundAction, destNodeName;
+                            for (const [nodeName, node] of Object.entries(nodes)) {
+                                if (node.transiciones && node.transiciones[transName]) {
+                                    foundAction = node.transiciones[transName].accion;
+                                    destNodeName = node.transiciones[transName].destino;
+                                    break;
                                 }
-                                if (!foundAction) throw new Error(`Transición '${transName}' no encontrada en el mapa '${suite.state_map}'`);
-                                finalAction = foundAction;
                             }
-
-                            if (Array.isArray(finalAction)) {
-                                for (const subAct of finalAction) {
-                                    await executeAction(subAct);
+                            if (!foundAction) throw new Error(`Transición '${transName}' no encontrada.`);
+                            await executeAction(foundAction);
+
+                            // Identidad
+                            const destNode = nodes[destNodeName];
+                            if (destNode && destNode.fingerprint) {
+                                const selectors = destNode.fingerprint.selectors || [destNode.fingerprint.selector];
+                                const { client } = await this.getMcpClient("wdio-mcp");
+                                for (const sel of selectors) {
+                                    const vRes = await client.callTool({ name: "wait_for_element", arguments: { selector: sel, timeout: 5000 } });
+                                    if (vRes.isError) throw new Error(`Identidad fallida: ${sel}`);
                                 }
-                                return;
+                                subRes.output = (subRes.output || "") + "\n✅ Identidad Multivectorial confirmada.";
                             }
+                            return;
+                        }
 
-                            const interpolatedAction = this.interpolate(finalAction, data);
-
-                            if (interpolatedAction.startsWith("sh:")) {
-                                subRes.output = (await execAsync(interpolatedAction.replace("sh:", ""))).stdout;
-                            } else if (interpolatedAction.startsWith("mcp:")) {
-                                const raw = interpolatedAction.replace("mcp:", "").trim();
-                                const slashIndex = raw.indexOf("/");
-                                const serverName = raw.substring(0, slashIndex);
-                                const rest = raw.substring(slashIndex + 1);
-                                const spaceIndex = rest.indexOf(" ");
-                                const toolName = spaceIndex === -1 ? rest : rest.substring(0, spaceIndex);
-                                const toolArgs = JSON.parse(spaceIndex === -1 ? "{}" : rest.substring(spaceIndex + 1));
-
-                                const { client } = await this.getMcpClient(serverName);
-                                lastResult = await client.callTool({ name: toolName, arguments: toolArgs }, undefined, { timeout: 600000 });
-
-                                if (lastResult.isError && toolName !== "close_session") {
-                                    throw new Error(lastResult.content?.[0]?.text || "Error desconocido en herramienta MCP");
-                                }
-
-                                if (lastResult.content) {
-                                    for (const item of lastResult.content) {
-                                        if (item.text) {
-                                            subRes.output = (subRes.output || "") + "\n" + maskSecrets(item.text);
-                                        }
-                                    }
-                                }
-
-                                if (lastResult.content) {
-                                    let base64 = "";
-                                    for (const item of lastResult.content) {
-                                        if (item.type === "image") base64 = item.data;
-                                        else if (item.text && (item.text.startsWith("iVBOR") || item.text.length > 5000)) base64 = item.text;
-                                    }
-                                    if (base64) {
-                                        subRes.image = base64.startsWith("data:") ? base64 : `data:image/png;base64,${base64}`;
-                                        subRes.output = (subRes.output || "") + "\nEvidencia visual capturada.";
-                                    }
+                        const interpolated = this.interpolate(act, data);
+                        if (interpolated.startsWith("sh:")) {
+                            const { stdout, stderr } = await execAsync(interpolated.replace("sh:", "").trim());
+                            subRes.output = (subRes.output || "") + "\n" + stdout + (stderr ? "\nERR: " + stderr : "");
+                        } else if (interpolated.startsWith("mcp:")) {
+                            const raw = interpolated.replace("mcp:", "").trim();
+                            const slash = raw.indexOf("/");
+                            const space = raw.indexOf(" ", slash);
+                            const srv = raw.substring(0, slash);
+                            const tool = space === -1 ? raw.substring(slash + 1) : raw.substring(slash + 1, space);
+                            const args = JSON.parse(space === -1 ? "{}" : raw.substring(space + 1));
+                            const { client } = await this.getMcpClient(srv);
+                            const res = await client.callTool({ name: tool, arguments: args });
+                            if (res.content) {
+                                for (const item of res.content) {
+                                    if (item.text) subRes.output = (subRes.output || "") + "\n" + item.text;
+                                    if (item.type === "image") subRes.image = item.data.startsWith("data:") ? item.data : `data:image/png;base64,${item.data}`;
                                 }
                             }
-                        } catch (e) {
-                            subRes.status = "failed";
-                            subRes.error = e.message;
-                            throw e;
                         }
                     };
-
                     await executeAction(action);
                 } catch (e) {
                     actionRes.status = "failed";
@@ -229,44 +146,24 @@ export class MaquinaDeEstados {
         };
 
         try {
-            await runActions(suite.beforeSuite, results.hooks.beforeSuite);
             for (const caseName of suite.tests) {
                 const testCase = this.casosPrueba.get(caseName);
                 if (!testCase) continue;
-
-                let dataRows = [null];
-                if (testCase.data) {
-                    if (Array.isArray(testCase.data)) dataRows = testCase.data;
-                    else if (typeof testCase.data === "string") dataRows = await this.loadExternalData(testCase.data) || [null];
-                }
-
-                for (let i = 0; i < dataRows.length; i++) {
-                    const row = dataRows[i];
-                    const suffix = row ? ` [Iteration ${i + 1}]` : "";
-                    const caseRes = { name: testCase.name + suffix, steps: [], status: "passed", hooks: { beforeCase: [], afterCase: [] } };
-                    results.cases.push(caseRes);
-
+                const caseRes = { name: testCase.name, steps: [], status: "passed" };
+                results.cases.push(caseRes);
+                for (const step of testCase.steps) {
+                    const stepRes = { name: step.name, actions: [], status: "passed" };
+                    caseRes.steps.push(stepRes);
                     try {
-                        await runActions(suite.beforeCase, caseRes.hooks.beforeCase, row);
-                        for (const step of testCase.steps) {
-                            const stepRes = { name: step.name, actions: [], status: "passed" };
-                            caseRes.steps.push(stepRes);
-                            try {
-                                await runActions(suite.beforeStep, stepRes.actions, row);
-                                await runActions(step.actions, stepRes.actions, row);
-                            } catch (e) {
-                                stepRes.status = "failed";
-                                stepRes.error = e.message;
-                                throw e;
-                            } finally {
-                                await runActions(suite.afterStep, stepRes.actions, row);
-                            }
+                        await runActions(step.actions || [step.action], stepRes.actions);
+                        if (step.assert) {
+                            const aRes = { action: `[ASSERT] ${step.assert}`, status: "passed" };
+                            stepRes.actions.push(aRes);
+                            await runActions([step.assert], stepRes.actions);
                         }
-                        await runActions(suite.afterCase, caseRes.hooks.afterCase, row);
-                    } catch (e) { caseRes.status = "failed"; caseRes.error = e.message; }
+                    } catch (e) { stepRes.status = "failed"; throw e; }
                 }
             }
-            await runActions(suite.afterSuite, results.hooks.afterSuite);
         } finally {
             for (const { transport } of this.mcpClients.values()) await transport.close();
             this.mcpClients.clear();
@@ -276,338 +173,126 @@ export class MaquinaDeEstados {
     }
 
     async finalizarReporte(dir, data) {
-        const renderActions = (actions) => actions.map(a => `
-            <div style="margin-top:15px; border-bottom: 1px solid #1e293b; padding-bottom: 15px;">
-                <div style="display:flex; justify-content:space-between; align-items:center;">
-                    <code style="color: #60a5fa; font-weight:bold;">${a.action}</code>
-                    <span style="font-size:0.7em; padding:2px 8px; border-radius:10px; background:${a.status === 'passed' ? '#065f46' : '#991b1b'}; color:white;">${a.status}</span>
+        const renderActions = (actions) => actions.map(a => {
+            const isAssert = a.action.startsWith("[ASSERT]");
+            const isIdentity = a.output && a.output.includes("Identidad");
+            return `
+            <div style="border-left: 4px solid ${a.status === 'passed' ? (isAssert ? '#10b981' : '#3b82f6') : '#ef4444'}; background: rgba(15, 23, 42, 0.8); padding: 20px; border-radius: 12px; margin-bottom: 15px; border: 1px solid #1e293b;">
+                <div style="display:flex; justify-content:space-between; margin-bottom: 10px;">
+                    <span style="font-weight: 600; color: ${isAssert ? '#10b981' : '#94a3b8'};">${isAssert ? '🛡️ VALIDACIÓN' : '⚙️ ACCIÓN'}</span>
+                    <span style="background:${a.status === 'passed' ? '#065f46' : '#991b1b'}; padding: 2px 8px; border-radius: 4px; font-size: 0.8em;">${a.status}</span>
                 </div>
-                ${a.image ? `<div style="margin-top:15px; text-align:center;"><img src="${a.image}" style="max-width:100%; border-radius:12px; box-shadow: 0 10px 30px rgba(0,0,0,0.5); border: 1px solid #334155;"></div>` : ""}
-                ${a.output ? `
-                    <details style="margin-top:10px;">
-                        <summary style="cursor:pointer; color:#64748b; font-size:0.8em; outline:none;">View technical logs</summary>
-                        <pre style="background:#020617; padding:15px; border-radius:8px; font-size:0.85em; color:#10b981; margin-top:10px; border:1px solid #1e293b; overflow-x:auto;">${a.output}</pre>
-                    </details>` : ""}
-                ${a.error ? `<pre style="background:#450a0a; padding:15px; border-radius:8px; font-size:0.85em; color:#fca5a5; margin-top:10px;">${a.error}</pre>` : ""}
-            </div>
-        `).join("");
-
-        const html = `<!DOCTYPE html><html lang="es"><head><meta charset="UTF-8"><title>SMS Dashboard V11.1 CSV-Ready</title>
-            <style>
-                @import url('https://fonts.googleapis.com/css2?family=Outfit:wght@300;400;600;800&display=swap');
-                body { font-family: 'Outfit', sans-serif; background: #020617; color: #f8fafc; padding: 60px; line-height: 1.6; }
-                .container { max-width: 1000px; margin: 0 auto; }
-                .card { background: #0f172a; border: 1px solid #1e293b; border-radius: 20px; padding: 40px; margin-bottom: 30px; box-shadow: 0 20px 50px rgba(0,0,0,0.3); }
-                .hook-label { background: #3b82f6; color: white; font-size: 0.7em; font-weight: 800; padding: 5px 12px; border-radius: 50px; text-transform: uppercase; margin-bottom: 15px; display: inline-block; letter-spacing: 1px; }
-                h1 { font-size: 3.5em; font-weight: 800; background: linear-gradient(to right, #60a5fa, #a855f7); -webkit-background-clip: text; -webkit-text-fill-color: transparent; margin-bottom: 0.2em; }
-                .step { border-left: 3px solid #3b82f6; padding-left: 30px; margin: 40px 0; }
-                h2 { font-size: 2em; margin-bottom: 1em; color: #f1f5f9; }
-                h3 { color: #94a3b8; font-weight: 400; text-transform: uppercase; font-size: 0.9em; letter-spacing: 2px; }
-            </style></head>
-        <body><div class="container">
-            <h1>SMS Dashboard</h1>
-            <p style="color: #64748b; font-size: 1.1em; margin-bottom: 40px;">Universal Data-Driven Framework • V11.2</p>
-            ${data.hooks.beforeSuite.length ? `<div class="card"><span class="hook-label">Global Setup</span>${renderActions(data.hooks.beforeSuite)}</div>` : ""}
+                <div style="color: #f8fafc; margin-bottom: 10px;">${isAssert ? a.action.replace("[ASSERT]", "").trim() : a.action}</div>
+                ${isIdentity ? `<div style="color: #34d399; font-size: 0.85em;">🔍 Identidad Multivectorial Confirmada</div>` : ""}
+                ${a.image ? `<div style="margin-top:10px; text-align:center;"><img src="${a.image}" style="max-width:100%; border-radius:8px;"></div>` : ""}
+                ${a.error ? `<pre style="color:#fca5a5; font-size:0.8em;">${a.error}</pre>` : ""}
+            </div>`;
+        }).join("");
+
+        const html = `<html><body style="background:#020617; color:#f8fafc; font-family:sans-serif; padding:50px;">
+            <h1 style="color:#60a5fa;">SMS Framework V12.5</h1>
             ${data.cases.map(c => `
-                <div class="card">
-                    <h3 style="color:#60a5fa; margin-bottom:10px;">TEST CASE EXECUTION</h3>
-                    <h2>${c.name}</h2>
-                    ${c.hooks.beforeCase.length ? `<div><span class="hook-label">Pre-Condition</span>${renderActions(c.hooks.beforeCase)}</div>` : ""}
-                    ${c.steps.map(s => `<div class="step"><h3>STEP: ${s.name}</h3>${renderActions(s.actions)}</div>`).join("")}
-                    ${c.hooks.afterCase.length ? `<div><span class="hook-label">Post-Condition</span>${renderActions(c.hooks.afterCase)}</div>` : ""}
-                </div>
-            `).join("")}
-            ${data.hooks.afterSuite.length ? `<div class="card"><span class="hook-label">Global Teardown</span>${renderActions(data.hooks.afterSuite)}</div>` : ""}
-        </div></body></html>`;
+                <div style="background:#0f172a; padding:30px; border-radius:20px; margin-bottom:30px; border:1px solid #1e293b;">
+                    <h2>CASE: ${c.name}</h2>
+                    ${c.steps.map(s => `<div><h3>STEP: ${s.name}</h3>${renderActions(s.actions)}</div>`).join("")}
+                </div>`).join("")}
+        </body></html>`;
         await fs.writeFile(path.join(dir, "index.html"), html);
-        await fs.writeFile(path.join(dir, "results.json"), JSON.stringify(data, null, 2));
     }
 }
 
 const maquina = new MaquinaDeEstados();
-const server = new McpServer({ name: "demo-state-machine", version: "11.1.0" });
-server.tool("execute_suite", "Ejecución de Suite Completa", {
-    name: z.string().describe("Nombre de la suite a ejecutar (ej: 'Suite_Login'). Buscará el archivo en /suites.")
-}, async ({ name }) => {
-    await maquina.cargar();
-    const dir = await maquina.ejecutarSuite(name);
-    return { content: [{ type: "text", text: `Reporte: ${dir}` }] };
-});
-
-server.tool("upsert_node", "Añadir o actualizar un nodo en el mapa de estados.", {
-    mapName: z.string().describe("Nombre del archivo del mapa (ej: 'home_map.json'). El servidor lo buscará en la carpeta /maps."),
-    nodeName: z.string().describe("Identificador único del nodo (ej: 'LOGIN_PAGE', 'HOME')."),
-    nodeData: z.object({
-        transiciones: z.any().optional().describe("Objeto que define las salidas del nodo. Ej: { 'IR_A_LOGIN': { 'destino': 'LOGIN_PAGE', 'accion': 'mcp:wdio-mcp/click_element ...' } }")
-    }).passthrough().describe("Datos completos del nodo, incluyendo transiciones y metadatos.")
-}, async ({ mapName, nodeName, nodeData }) => {
-    const mapPath = path.join(__dirname, 'maps', mapName);
-    let map = { nodos: {} };
-    try {
-        const content = await fs.readFile(mapPath, 'utf8');
-        map = JSON.parse(content);
-        if (!map.nodos) map = { nodos: map };
-    } catch (e) { }
-
-    map.nodos[nodeName] = nodeData;
-    await fs.mkdir(path.dirname(mapPath), { recursive: true });
-    await fs.writeFile(mapPath, JSON.stringify(map, null, 2));
-
-    // Generar/Actualizar Diagrama Mermaid
-    try {
-        let mermaid = "graph TD\n";
-        for (const [name, node] of Object.entries(map.nodos)) {
-            if (node.transiciones) {
-                for (const [transName, trans] of Object.entries(node.transiciones)) {
-                    mermaid += `  ${name} -- "${transName}" --> ${trans.destino}\n`;
-                }
-            }
-        }
-        const mermaidPath = mapPath.replace('.json', '.md');
-        await fs.writeFile(mermaidPath, `# 🗺️ Diagrama de Estados: ${mapName}\n\n\`\`\`mermaid\n${mermaid}\`\`\``);
-    } catch (me) {
-        process.stderr.write(`[WARN] Error generando Mermaid: ${me.message}\n`);
-    }
+const server = new McpServer({ name: "demo-state-machine", version: "12.5.0" });
 
-    return { content: [{ type: "text", text: `Nodo '${nodeName}' actualizado. Diagrama visual regenerado en maps/${mapName.replace('.json', '.md')}` }] };
-});
-
-server.tool("inspect_framework", "Inspeccionar integridad y listar entidades del framework", {
-    filter: z.optional(z.string())
-}, async () => {
-    const entities = { maps: [], test_cases: [], suites: [], health: [] };
-    const getFiles = async (dir) => {
-        try { return (await fs.readdir(path.join(__dirname, dir))).filter(f => f.endsWith('.json')); }
-        catch (e) { return []; }
+server.tool("init_project", "Instalación Inicial. Crea carpetas y archivos de plantilla.", {}, async () => {
+    const templates = {
+        'maps/template_map.json': { nodos: { HOME: { fingerprint: { selectors: ["~Login"] }, transiciones: { IR_A_LOGIN: { destino: "LOGIN", accion: "mcp:wdio-mcp/click_element {\"selector\":\"~Login\"}" } } } } },
+        'test_cases/template_case.json': { name: "TC_Ejemplo", steps: [{ name: "Ir a Login", action: "transicion:IR_A_LOGIN", assert: "sh:ls" }] },
+        'suites/template_suite.json': { name: "Suite_Ejemplo", state_map: "template_map.json", tests: ["TC_Ejemplo"] }
     };
-
-    entities.maps = await getFiles('maps');
-    entities.test_cases = await getFiles('test_cases');
-    entities.suites = await getFiles('suites');
-
-    // Validación de integridad simple
-    for (const suiteFile of entities.suites) {
-        try {
-            const suite = JSON.parse(await fs.readFile(path.join(__dirname, 'suites', suiteFile), 'utf8'));
-            if (!entities.maps.includes(suite.state_map)) {
-                entities.health.push(`❌ Suite '${suiteFile}' referencia a mapa inexistente: ${suite.state_map}`);
-            }
-            for (const tc of suite.tests) {
-                if (!entities.test_cases.includes(`${tc}.json`) && !entities.test_cases.includes(tc)) {
-                    entities.health.push(`❌ Suite '${suiteFile}' referencia a test case inexistente: ${tc}`);
-                }
-            }
-        } catch (e) { entities.health.push(`❌ Error leyendo suite '${suiteFile}': ${e.message}`); }
+    for (const [f, c] of Object.entries(templates)) {
+        const p = path.join(__dirname, f);
+        if (!fsSync.existsSync(p)) { await fs.mkdir(path.dirname(p), { recursive: true }); await fs.writeFile(p, JSON.stringify(c, null, 2)); }
     }
-
-    if (entities.health.length === 0) entities.health.push("✅ Estructura íntegra. Todos los vínculos son correctos.");
-
-    // Validación de integridad de Grafos (Nodos Huérfanos)
-    for (const mapFile of entities.maps) {
-        try {
-            const mapData = JSON.parse(await fs.readFile(path.join(__dirname, 'maps', mapFile), 'utf8'));
-            const nodos = mapData.nodos || mapData;
-            if (nodos && nodos["HOME"]) {
-                const reachable = new Set(["HOME"]);
-                const stack = ["HOME"];
-                while (stack.length > 0) {
-                    const current = stack.pop();
-                    const node = nodos[current];
-                    if (node && node.transiciones) {
-                        for (const t of Object.values(node.transiciones)) {
-                            if (t.destino && nodos[t.destino] && !reachable.has(t.destino)) {
-                                reachable.add(t.destino);
-                                stack.push(t.destino);
-                            }
-                        }
-                    }
-                }
-                const totalNodes = Object.keys(nodos);
-                const unreachable = totalNodes.filter(n => !reachable.has(n));
-                if (unreachable.length > 0) {
-                    entities.health.push(`⚠️ Mapa '${mapFile}': Nodos inalcanzables desde HOME: ${unreachable.join(', ')}`);
-                }
-            } else if (nodos && !nodos["HOME"]) {
-                entities.health.push(`⚠️ Mapa '${mapFile}': No tiene un nodo 'HOME' (inicio), no se puede validar el grafo.`);
-            }
-        } catch (e) { entities.health.push(`❌ Error validando grafo de '${mapFile}': ${e.message}`); }
-    }
-
-    return { content: [{ type: "text", text: JSON.stringify(entities, null, 2) }] };
-});
-
-server.tool("save_test_case", "Crear o actualizar un caso de prueba.", {
-    name: z.string().describe("Nombre identificador del test (ej: 'TC_Login_Exitoso')."),
-    steps: z.array(z.object({
-        name: z.string().optional().describe("Descripción amigable del paso (ej: 'Ingresar Usuario')."),
-        action: z.string().optional().describe("Acción a realizar. Puede ser un nombre de transición del mapa o un comando mcp:wdio-mcp/...")
-    }).passthrough()).describe("Lista ordenada de pasos lógicos a ejecutar.")
-}, async ({ name, steps }) => {
-    const fileName = name.endsWith('.json') ? name : `${name}.json`;
-    const filePath = path.join(__dirname, 'test_cases', fileName);
-    const testCase = { name: name.replace('.json', ''), steps };
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, JSON.stringify(testCase, null, 2));
-    return { content: [{ type: "text", text: `Caso de prueba '${name}' guardado correctamente.` }] };
-});
-
-server.tool("save_suite", "Crear o actualizar una suite de pruebas.", {
-    name: z.string().describe("Nombre de la suite (ej: 'Suite_E2E_Sanity')."),
-    state_map: z.string().describe("Archivo del mapa de estados a usar (ej: 'mob_perfecto_map.json')."),
-    tests: z.array(z.string()).describe("Lista de nombres de casos de prueba a incluir en la suite."),
-    beforeSuite: z.array(z.string()).optional().default([]).describe("Acciones globales antes de la suite (ej: iniciar sesión)."),
-    afterSuite: z.array(z.string()).optional().default([]).describe("Acciones globales tras la suite (ej: cerrar sesión).")
-}, async ({ name, state_map, tests, beforeSuite, afterSuite }) => {
-    const fileName = name.endsWith('.json') ? name : `${name}.json`;
-    const filePath = path.join(__dirname, 'suites', fileName);
-    const suite = { name: name.replace('.json', ''), state_map, tests, beforeSuite, afterSuite };
-    await fs.mkdir(path.dirname(filePath), { recursive: true });
-    await fs.writeFile(filePath, JSON.stringify(suite, null, 2));
-    return { content: [{ type: "text", text: `Suite '${name}' guardada correctamente.` }] };
+    return { content: [{ type: "text", text: "✨ Entorno Inicializado. Usa 'sms_builder' para empezar el diseño." }] };
 });
 
-server.tool("design_wizard", "Asistente paso a paso para diseñar la máquina de estados", {
-    action: z.enum(["start", "add_node", "add_transition", "save"]),
-    data: z.record(z.any()).optional().describe("Datos según la fase: { mapName }, { nodeName }, { label, destino, accion }")
+server.tool("sms_builder", "Diseño Guiado: Nodos -> Tests -> Suite.", {
+    action: z.enum(["start", "add_node", "add_fingerprint", "done_node", "add_test", "add_step", "add_assert", "save_test", "assemble_suite"]),
+    data: z.record(z.any())
 }, async ({ action, data }) => {
-    const contextPath = path.join(__dirname, 'data', '.design_context.json');
-    let context = { step: "IDLE", mapName: "", nodeName: "", transitions: {} };
-
-    try { context = JSON.parse(await fs.readFile(contextPath, 'utf8')); } catch (e) { }
-
-    if (action === "start") {
-        context = { step: "SELECT_NODE", mapName: data.mapName || "default_map.json", nodeName: "", transitions: {} };
-        await fs.writeFile(contextPath, JSON.stringify(context, null, 2));
-        return { content: [{ type: "text", text: `🧙‍♂️ Wizard Iniciado: Trabajando en '${context.mapName}'.\n\nPASO 1: ¿Qué nombre le damos al nodo? (Usa action: 'add_node')` }] };
-    }
-
-    if (action === "add_node" && context.step === "SELECT_NODE") {
-        context.nodeName = data.nodeName;
-        context.step = "ADD_TRANSITIONS";
-        await fs.writeFile(contextPath, JSON.stringify(context, null, 2));
-        return { content: [{ type: "text", text: `📍 Nodo '${context.nodeName}' identificado.\n\nPASO 2: Define una transición. (Usa action: 'add_transition' con { label, destino, accion }). Puedes llamar a esto varias veces.` }] };
+    const ctxPath = path.join(__dirname, '.sms_builder_context.json');
+    let ctx = { step: "IDLE", nodes: {}, tests: [] };
+    try { ctx = JSON.parse(fsSync.readFileSync(ctxPath, 'utf8')); } catch (e) {}
+
+    switch (action) {
+        case "start":
+            ctx = { step: "DESIGN", mapName: data.mapName, nodes: {}, tests: [] };
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `🏗️ Diseñando Mapa: ${data.mapName}. Añade un nodo (action: 'add_node' { nodeName }).` }] };
+        
+        case "add_node":
+            ctx.currentNode = { name: data.nodeName, transiciones: {}, fingerprint: null };
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `📍 Nodo '${data.nodeName}'. MANDATORIO: Añade huella (action: 'add_fingerprint' { selector }).` }] };
+        
+        case "add_fingerprint":
+            if (!ctx.currentNode.fingerprint) ctx.currentNode.fingerprint = { selectors: [] };
+            ctx.currentNode.fingerprint.selectors.push(data.selector);
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `🧬 Vector añadido. ¿Otro o 'done_node'?` }] };
+        
+        case "done_node":
+            ctx.nodes[ctx.currentNode.name] = { fingerprint: ctx.currentNode.fingerprint, transiciones: ctx.currentNode.transiciones };
+            await fs.writeFile(path.join(__dirname, 'maps', `${ctx.mapName}.json`), JSON.stringify({ nodos: ctx.nodes }, null, 2));
+            delete ctx.currentNode;
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `✅ Nodo guardado. ¿Otro ('add_node') o Tests ('add_test')?` }] };
+
+        case "add_test":
+            ctx.currentTest = { name: data.testName, steps: [] };
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `🧪 Test '${data.testName}'. Añade pasos (action: 'add_step' { name, action }).` }] };
+        
+        case "add_step":
+            ctx.currentStep = { name: data.name, action: data.action };
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `✅ Paso añadido. ¿Assert? (action: 'add_assert' { assert }) o siguiente ('add_step').` }] };
+        
+        case "add_assert":
+            ctx.currentStep.assert = data.assert;
+            ctx.currentTest.steps.push(ctx.currentStep);
+            delete ctx.currentStep;
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `🛡️ Assert añadido. ¿Siguiente paso ('add_step') o guardar ('save_test')?` }] };
+        
+        case "save_test":
+            if (ctx.currentStep) ctx.currentTest.steps.push(ctx.currentStep);
+            await fs.writeFile(path.join(__dirname, 'test_cases', `${ctx.currentTest.name}.json`), JSON.stringify(ctx.currentTest, null, 2));
+            ctx.tests.push(ctx.currentTest.name);
+            delete ctx.currentTest;
+            fsSync.writeFileSync(ctxPath, JSON.stringify(ctx, null, 2));
+            return { content: [{ type: "text", text: `✅ Test guardado. ¿Otro ('add_test') o Suite ('assemble_suite')?` }] };
+        
+        case "assemble_suite":
+            const suite = { name: data.suiteName, state_map: `${ctx.mapName}.json`, tests: ctx.tests };
+            await fs.writeFile(path.join(__dirname, 'suites', `${data.suiteName}.json`), JSON.stringify(suite, null, 2));
+            fsSync.unlinkSync(ctxPath);
+            return { content: [{ type: "text", text: `🎊 Suite '${data.suiteName}' lista. Corre con 'sms_executor'.` }] };
     }
-
-    if (action === "add_transition" && context.step === "ADD_TRANSITIONS") {
-        context.transitions[data.label] = { destino: data.destino, accion: data.accion };
-        await fs.writeFile(contextPath, JSON.stringify(context, null, 2));
-        return { content: [{ type: "text", text: `🔄 Transición '${data.label}' añadida.\n\n¿Quieres añadir otra o guardar? (Usa action: 'save' para finalizar)` }] };
-    }
-
-    if (action === "save" && context.step === "ADD_TRANSITIONS") {
-        const result = await server.callTool("upsert_node", {
-            mapName: context.mapName,
-            nodeName: context.nodeName,
-            nodeData: { transiciones: context.transitions }
-        });
-        await fs.unlink(contextPath); // Reset wizard
-        return result;
-    }
-
-    return { content: [{ type: "text", text: `❌ Acción no permitida en el estado actual (${context.step}).` }] };
 });
 
-server.tool("begin_design", "Iniciar una sesión de diseño guiado para una aplicación", {
-    appName: z.string().describe("Nombre de la aplicación a diseñar (ej: 'AdvantageShopping').")
-}, async ({ appName }) => {
-    const rules = `
-🎭 HAS ENTRADO EN MODO DISEÑO (SMS ARCHITECT) 🎭
-Estás diseñando la estructura para: ${appName}
-
-REGLAS CRÍTICAS DE SUPERVIVENCIA:
-1. ❌ PROHIBIDO editar archivos JSON manualmente.
-2. ❌ PROHIBIDO usar los campos 'nodes' o 'edges'. NO SOMOS UNA LIBRERÍA DE GRÁFICOS.
-3. ✅ USA EXCLUSIVAMENTE 'upsert_node' para crear o actualizar estados.
-4. ✅ ESTRUCTURA OBLIGATORIA: { "nodos": { "NOMBRE_NODO": { "transiciones": {} } } }
-5. 🔄 FLUJO: Primero propón el diseño en texto -> Pide confirmación -> Usa la herramienta.
-
-Dime qué pantalla o flujo quieres empezar a mapear para ${appName}.
-    `;
-    return { content: [{ type: "text", text: rules }] };
-});
-
-server.tool("init_project", "Inicializa el proyecto con carpetas y archivos de plantilla", {
-    force: z.optional(z.boolean()).default(false)
-}, async ({ force }) => {
-    await ensureDirectories();
-
-    const templates = {
-        'maps/template_map.json': {
-            nodos: {
-                HOME: {
-                    transiciones: {
-                        IR_A_LOGIN: { destino: "LOGIN", accion: "mcp:wdio-mcp/click_element { \"selector\": \"~Login\" }" }
-                    }
-                },
-                LOGIN: {
-                    transiciones: {
-                        VOLVER: { destino: "HOME", accion: "mcp:wdio-mcp/click_element { \"selector\": \"~Back\" }" }
-                    }
-                }
-            }
-        },
-        'test_cases/template_case.json': {
-            name: "Template Case",
-            steps: [
-                { name: "Ir a Login", action: "IR_A_LOGIN" },
-                { name: "Verificar Pantalla", action: "mcp:wdio-mcp/get_screenshot {}" }
-            ]
-        },
-        'suites/template_suite.json': {
-            name: "Template Suite",
-            state_map: "template_map.json",
-            tests: ["template_case"],
-            beforeSuite: ["mcp:wdio-mcp/start_session { \"platform\": \"android\", \"provider\": \"perfecto\" }"],
-            afterSuite: ["mcp:wdio-mcp/close_session {}"]
-        }
-    };
-
-    for (const [relPath, content] of Object.entries(templates)) {
-        const fullPath = path.join(__dirname, relPath);
-        try {
-            if (!force) {
-                try {
-                    await fs.access(fullPath);
-                    continue; // Skip if exists
-                } catch (e) { }
-            }
-            await fs.writeFile(fullPath, JSON.stringify(content, null, 2));
-        } catch (e) {
-            process.stderr.write(`[WARN] Error creando template ${relPath}: ${e.message}\n`);
-        }
-    }
-
-    return {
-        content: [{
-            type: "text",
-            text: "✅ Instalación completada con éxito.\n\nComo este es un proyecto nuevo, el siguiente paso es definir tu aplicación. Por favor, llama a la herramienta `begin_design` para empezar a mapear tus primeros estados."
-        }]
-    };
-});
-
-server.tool("framework_menu", "Panel de control para elegir entre Modo Diseño o Modo Ejecución", {}, async () => {
-    return {
-        content: [{
-            type: "text",
-            text: "🎮 **Framework Control Panel**\n\n¿Qué deseas hacer ahora?\n1. 🎨 **Modo Diseño**: Añadir o modificar nodos y mapas (Usa `begin_design`).\n2. 🚀 **Modo Ejecución**: Lanzar suites de pruebas existentes (Usa `execute_suite`).\n3. 🔍 **Auditoría**: Revisar la integridad del sistema (Usa `inspect_framework`)."
-        }]
-    };
+server.tool("sms_executor", "Corre una suite y genera reporte.", { suiteName: z.string() }, async ({ suiteName }) => {
+    await maquina.cargar();
+    const dir = await maquina.ejecutarSuite(suiteName);
+    return { content: [{ type: "text", text: `🚀 Reporte: ${dir}` }] };
 });
 
-async function ensureDirectories() {
-    const dirs = ['maps', 'suites', 'test_cases', 'reports', 'data'];
-    for (const dir of dirs) {
-        const dirPath = path.join(__dirname, dir);
-        try {
-            await fs.mkdir(dirPath, { recursive: true });
-        } catch (e) {
-            process.stderr.write(`[WARN] Error creando directorio ${dir}: ${e.message}\n`);
-        }
-    }
-}
-
 async function main() {
-    await ensureDirectories();
+    for (const d of ['maps', 'suites', 'test_cases', 'reports']) {
+        const p = path.join(__dirname, d);
+        if (!fsSync.existsSync(p)) await fs.mkdir(p, { recursive: true });
+    }
     await maquina.cargar();
     const transport = new StdioServerTransport();
     await server.connect(transport);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-state-machine-test-framework",
-  "version": "1.2.3",
+  "version": "1.2.7",
   "description": "High-fidelity State Machine MCP Server for autonomous E2E testing orchestration.",
   "main": "index.js",
   "type": "module",