@saulwade/swl-ses 1.3.8 → 1.4.0

package/comandos/swl/exportar-vault.md

@@ -55,6 +55,66 @@ documentado en `reglas/consultar-vault-primero.md § Workflow forzoso para
 escritura al vault`. El bloqueo por `proteccion-rutas.js` no es una falla a
 esquivar — es una señal de que el canal correcto es el MCP.
 
+### 0c — Verificar que el vault activo de Obsidian apunta a `Vault\SWL\` (CRÍTICO)
+
+> Origen del paso: sesión 2026-05-13 v1.4.0. El MCP de Obsidian resuelve paths
+> relativos contra el **vault que Obsidian tiene abierto**, no contra una
+> ruta hardcodeada en el plugin. Si Obsidian abrió un vault distinto del
+> esperado (ej. `F:\Google Drive\Developer\Obsidian\Vault\` raíz en lugar
+> de `Vault\SWL\`), todas las escrituras del MCP irán al vault equivocado.
+> El plugin **crea carpetas inexistentes** sobre la marcha, así que ni
+> siquiera obtendrás error — los archivos terminan en una ubicación huérfana.
+
+Verifica antes de cualquier llamada MCP:
+
+```bash
+# Path canónico de la config global de Obsidian en Windows
+APP="$APPDATA/obsidian/obsidian.json"
+node -e "
+const fs = require('fs');
+const data = JSON.parse(fs.readFileSync(process.argv[1], 'utf8'));
+const abierto = Object.values(data.vaults).find(v => v.open === true);
+console.log('Vault abierto:', abierto ? abierto.path : 'NINGUNO');
+console.log('Esperado:      F:\\\\Google Drive\\\\Developer\\\\Obsidian\\\\Vault\\\\SWL');
+console.log('OK:', abierto && abierto.path.endsWith('SWL') ? 'sí' : 'NO');
+" "$APP"
+```
+
+Resultado esperado:
+
+```
+Vault abierto: F:\Google Drive\Developer\Obsidian\Vault\SWL
+Esperado:      F:\Google Drive\Developer\Obsidian\Vault\SWL
+OK: sí
+```
+
+Si `OK: NO` o `Vault abierto: NINGUNO`, **NO usar MCP** — caer al filesystem
+para esta sesión y reportar al usuario que debe abrir el vault `SWL` en
+Obsidian (File → Open vault → seleccionar `F:\Google Drive\Developer\Obsidian\Vault\SWL`).
+
+### 0d — Verificar que la apiKey del MCP coincide con la del plugin activo
+
+> Origen: cuando el vault activo cambia, la apiKey del plugin Local REST API
+> cambia (cada vault tiene su propio `.obsidian/plugins/obsidian-local-rest-api/data.json`
+> con apiKey, cert y privateKey distintos). El MCP server registrado en
+> Claude.ai tiene una apiKey hardcodeada — si no se actualiza tras cambiar de
+> vault, todas las llamadas retornan `40101 Authorization required`.
+
+Si tras `ToolSearch` el MCP carga sus tools pero la primera llamada (ej.
+`obsidian_list_files_in_dir`) retorna `Error 40101: Authorization required`,
+el síntoma es claro: apiKey desincronizada.
+
+Acción:
+1. Leer la apiKey actual del plugin con
+   `grep '"apiKey"' "F:/Google Drive/Developer/Obsidian/Vault/SWL/.obsidian/plugins/obsidian-local-rest-api/data.json"`
+2. Reportar al usuario que actualice en **claude.ai → Settings → Connectors
+   → Obsidian → API Key**. Disconnect + Reconnect tras pegar el valor.
+3. Mientras tanto, usar filesystem como fallback para escribir al Inbox.
+
+Si hay procesos zombie de Obsidian o `mcp-obsidian` cliente con apiKey
+cacheada, requieren terminación + reinicio de Claude Code para tomar la
+nueva apiKey.
+
 ## Paso 1 — Identificación del proyecto actual
 
 Detecta qué proyecto eres leyendo:
@@ -296,6 +356,40 @@ escribe a `_userland/staging/<timestamp>.md` dentro del CWD, luego mueve con
 Reportar al usuario qué canal se usó:
 - Canal A → `[OK] Vía: MCP Obsidian (puerto 27124)`
 - Canal B → `[OK] Vía: filesystem directo (MCP no disponible)`
+- Canal Híbrido → `[OK] Vía: filesystem para Inbox, MCP para promociones`
+
+### Modo HÍBRIDO (validado en sesión 2026-05-13)
+
+Cuando la sesión incluye **autorización ampliada para promover documentos**
+a `02-Projects/`, `07-Decisions/` y `04-Resources/`, el flujo óptimo combina
+ambos canales:
+
+1. **Inbox** (`00-Inbox/YYYY-MM-DD_HHMM_export-{slug}.md`): usar siempre
+   **filesystem directo via Bash heredoc con ruta absoluta** (canal B). Razón:
+   el Bash heredoc bypassa cualquier desalineación del vault activo de
+   Obsidian — escribe directamente al disco en la ruta exacta.
+
+2. **Promociones** (a `02-Projects/`, `07-Decisions/`, `04-Resources/`):
+   usar **MCP append_content** (canal A) tras validar Pasos 0c y 0d. Razón:
+   las promociones requieren enlaces bidireccionales con `[[...]]` que el
+   plugin de Obsidian indexa al detectar la escritura. El filesystem directo
+   crea el archivo pero no dispara la reindexación hasta que Obsidian
+   detecte el cambio.
+
+3. **Aprobación de revisiones** (cambiar `status: pending-review` → `reviewed`
+   en frontmatter): si el archivo está en `00-Inbox/`, usar `sed` via Bash;
+   si está en `02-Projects/` etc., usar `mcp__obsidian__obsidian_patch_content`
+   con `target_type: "frontmatter"`. Validado que `patch_content` puede
+   responder 404 en algunos archivos pre-existentes — caer al filesystem si
+   falla.
+
+Reportar al usuario el desglose final del modo híbrido:
+
+```
+[OK] Inbox creado via filesystem: F:\...\00-Inbox\...md
+[OK] 3 promociones via MCP: 02-Projects, 07-Decisions, 04-Resources
+[OK] Revisión aprobada (reviewed: true) en el Inbox
+```
 
 ## Paso 5 — Confirmación
 
@@ -373,6 +467,20 @@ Próximo paso: al abrir el vault, ejecuta:
 
 ## Historial de cambios del comando
 
+- **v1.4.0** (2026-05-13) — Agregados Pasos 0c y 0d con verificación previa
+  del vault activo de Obsidian y de la apiKey del MCP. Origen: sesión
+  2026-05-13 con autorización ampliada del usuario para promover docs;
+  el MCP escribió `02-Projects/DEV - swl-ses.md` en `Vault\` raíz en lugar
+  de `Vault\SWL\` porque Obsidian tenía abierto el vault un nivel arriba
+  del esperado. Hallazgo crítico: el plugin Local REST API resuelve paths
+  relativos contra el vault que Obsidian tiene abierto en `obsidian.json`
+  global, no contra una ruta hardcodeada. Si el vault activo está mal,
+  el MCP escribe a la ubicación equivocada sin error (el plugin crea
+  carpetas inexistentes). Agregado también Paso 0d para apiKey
+  desincronizada (síntoma `40101 Authorization required`). Y nuevo
+  modo HÍBRIDO en Paso 4: filesystem directo para Inbox + MCP para
+  promociones, validado en la misma sesión.
+
 - **v1.3.8** (2026-05-11) — Agregado flujo MCP-first en Paso 4 con detección
   en Paso 0b. Origen: en la sesión v1.3.4 → v1.3.8 el comando defaultó a
   `Write` directo al filesystem que fue bloqueado por `proteccion-rutas.js`.

package/comandos/swl/nuevo-proyecto.md

@@ -135,11 +135,33 @@ Estructura:
 - Si el usuario no definió fases claras, propón una división lógica basada en las respuestas del Bloque C
 - Estado inicial de todas las fases: "Pendiente"
 
-## Paso 6 — Reporte al usuario
+## Paso 6 — Generar CLAUDE.md inicial del proyecto
+
+Si NO existe `CLAUDE.md` en la raíz del proyecto, generarlo con la estructura
+mínima definida en `/swl:claudemd init-project`. **OBLIGATORIO** incluir como
+primera sección bajo el título:
+
+```markdown
+## Reglas obligatorias
+
+@reglas/usar-sistema-swl.md
+```
+
+Esta referencia carga la matriz operacional del sistema SWL al inicio de cada
+sesión del proyecto y previene que el agente haga trabajo directo cuando
+existe un componente especializado. Sin ella, el proyecto pierde el contrato
+de uso del sistema SWL.
+
+Si ya existe `CLAUDE.md` (verificado en Paso 1), revisar que incluya
+`@reglas/usar-sistema-swl.md` en la sección de reglas obligatorias. Si NO
+lo incluye, agregarlo en este paso preservando el resto del contenido.
+
+## Paso 7 — Reporte al usuario
 
 Al terminar, reporta:
 
-1. Lista de archivos creados con sus rutas absolutas
+1. Lista de archivos creados con sus rutas absolutas (incluyendo CLAUDE.md
+   si se generó o se modificó)
 2. Resumen de la investigación del agente (cuando esté disponible)
 3. Próximo paso recomendado: "Para comenzar a trabajar en la Fase 1, usa `/swl:discutir-fase 1`"
 4. Si encontraste riesgos o ambigüedades durante la entrevista, listarlos aquí como "Puntos a resolver"

package/gateway/adapters/base.js

@@ -0,0 +1,109 @@
+'use strict';
+
+/**
+ * Base Adapter — Clase base abstracta para adaptadores de plataforma.
+ *
+ * Cada plataforma (Telegram, Discord, Webhook) extiende esta clase
+ * e implementa los métodos abstractos. El gateway/index.js orquesta
+ * múltiples adaptadores de forma uniforme.
+ *
+ * Patrón adoptado de Hermes Agent (gateway/platforms/base.py).
+ *
+ * @module gateway/adapters/base
+ */
+
+/**
+ * @abstract
+ */
+class BaseAdapter {
+  /**
+   * @param {string} name   - Nombre de la plataforma (ej: 'telegram').
+   * @param {object} config - Configuración específica de la plataforma.
+   */
+  constructor(name, config) {
+    if (new.target === BaseAdapter) {
+      throw new Error('BaseAdapter es abstracto — usar un adaptador concreto.');
+    }
+    this.name    = name;
+    this.config  = config;
+    this.running = false;
+    this._messageHandler = null;
+  }
+
+  /**
+   * Inicia la conexión con la plataforma.
+   * @abstract
+   * @returns {Promise<void>}
+   */
+  async start() {
+    throw new Error(`${this.name}: start() no implementado`);
+  }
+
+  /**
+   * Detiene la conexión con la plataforma.
+   * @abstract
+   * @returns {Promise<void>}
+   */
+  async stop() {
+    this.running = false;
+  }
+
+  /**
+   * Envía un mensaje formateado a la plataforma.
+   * @abstract
+   * @param {object} message
+   * @param {string} message.text    - Texto del mensaje (Markdown).
+   * @param {string} [message.chatId] - Destino específico.
+   * @param {string} [message.type]   - Tipo: 'notification', 'alert', 'response'.
+   * @returns {Promise<boolean>} true si se envió correctamente.
+   */
+  async send(message) {
+    throw new Error(`${this.name}: send() no implementado`);
+  }
+
+  /**
+   * Registra un handler para mensajes entrantes de la plataforma.
+   * @param {function} handler - Callback (message) => void.
+   */
+  onMessage(handler) {
+    this._messageHandler = handler;
+  }
+
+  /**
+   * Emite un mensaje entrante al handler registrado.
+   * @protected
+   * @param {object} message
+   */
+  _emitMessage(message) {
+    if (typeof this._messageHandler === 'function') {
+      this._messageHandler({
+        platform: this.name,
+        ...message,
+      });
+    }
+  }
+
+  /**
+   * Formatea un mensaje SWL para la plataforma específica.
+   * Override en cada adaptador para formato nativo (embeds, markdown, etc.).
+   *
+   * @param {object} swlMessage - Mensaje del sistema SWL.
+   * @returns {string} Texto formateado para la plataforma.
+   */
+  formatMessage(swlMessage) {
+    const { jobName, status, output, type } = swlMessage.payload || swlMessage;
+    const lines = [];
+
+    if (type === 'gateway_notification' || jobName) {
+      lines.push(`*${jobName || 'SWL Notificación'}*`);
+      if (status) lines.push(`Estado: ${status}`);
+      if (output) lines.push(`\`\`\`\n${output.substring(0, 500)}\n\`\`\``);
+    } else {
+      lines.push(swlMessage.text || JSON.stringify(swlMessage));
+    }
+
+    return lines.join('\n');
+  }
+}
+
+module.exports = BaseAdapter;

package/gateway/adapters/discord.js

@@ -0,0 +1,167 @@
+'use strict';
+
+/**
+ * Discord Adapter — Adaptador de plataforma para Discord.
+ *
+ * Usa discord.js para conectar un bot. Soporta:
+ *   - Recepción de mensajes en canal dedicado
+ *   - Envío con embeds para notificaciones estructuradas
+ *   - Comandos slash nativos
+ *   - Filtro por guildId y channelId
+ *
+ * Dependencia: discord.js (npm install discord.js)
+ * Si no está instalada, el adaptador se desactiva silenciosamente.
+ *
+ * Inspirado en Hermes Agent (gateway/platforms/discord.py).
+ *
+ * @module gateway/adapters/discord
+ */
+
+const BaseAdapter = require('./base');
+
+/** Límite de caracteres por mensaje de Discord. */
+const MAX_MSG_LENGTH = 2000;
+
+class DiscordAdapter extends BaseAdapter {
+  constructor(config) {
+    super('discord', config);
+    this._client = null;
+  }
+
+  async start() {
+    let Discord;
+    try {
+      Discord = require('discord.js');
+    } catch (_) {
+      console.log('[discord] discord.js no instalado. Ejecutar: npm install discord.js');
+      return;
+    }
+
+    const token = this.config.token || process.env.DISCORD_BOT_TOKEN;
+    if (!token) {
+      console.log('[discord] Token no configurado. Establecer DISCORD_BOT_TOKEN.');
+      return;
+    }
+
+    const { Client, GatewayIntentBits } = Discord;
+
+    this._client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+      ],
+    });
+
+    this._client.on('ready', () => {
+      this.running = true;
+      console.log(`[discord] Bot conectado como ${this._client.user.tag}`);
+    });
+
+    this._client.on('messageCreate', (msg) => {
+      // Ignorar mensajes del bot
+      if (msg.author.bot) return;
+
+      // Filtrar por guild y canal si están configurados
+      if (this.config.guildId && msg.guildId !== this.config.guildId) return;
+      if (this.config.channelId && msg.channelId !== this.config.channelId) return;
+
+      const text    = msg.content || '';
+      const parts   = text.split(/\s+/);
+      const command = parts[0].startsWith('/') ? parts[0] : null;
+      const args    = command ? parts.slice(1).join(' ') : '';
+
+      this._emitMessage({
+        chatId:    msg.channelId,
+        userId:    msg.author.id,
+        userName:  msg.author.username,
+        text:      text,
+        command:   command,
+        args:      args,
+        guildId:   msg.guildId,
+        raw:       msg,
+      });
+    });
+
+    this._client.on('error', (err) => {
+      console.error(`[discord] Error: ${err.message}`);
+    });
+
+    await this._client.login(token);
+    console.log('[discord] Adaptador iniciado.');
+  }
+
+  async stop() {
+    if (this._client) {
+      try { await this._client.destroy(); } catch (_) {}
+      this._client = null;
+    }
+    this.running = false;
+    console.log('[discord] Adaptador detenido.');
+  }
+
+  async send(message) {
+    if (!this._client) return false;
+
+    const channelId = message.chatId || this.config.channelId;
+    if (!channelId) return false;
+
+    try {
+      const channel = await this._client.channels.fetch(channelId);
+      if (!channel || !channel.isTextBased()) return false;
+
+      const embed = this._buildEmbed(message);
+      if (embed) {
+        await channel.send({ embeds: [embed] });
+      } else {
+        const text = this.formatMessage(message);
+        // Split si excede límite
+        if (text.length > MAX_MSG_LENGTH) {
+          const chunks = [];
+          for (let i = 0; i < text.length; i += MAX_MSG_LENGTH) {
+            chunks.push(text.substring(i, i + MAX_MSG_LENGTH));
+          }
+          for (const chunk of chunks) await channel.send(chunk);
+        } else {
+          await channel.send(text);
+        }
+      }
+      return true;
+    } catch (err) {
+      console.error(`[discord] Error enviando: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Construye un embed de Discord para notificaciones estructuradas.
+   * @private
+   */
+  _buildEmbed(message) {
+    const payload = message.payload || message;
+    if (!payload.jobName && !payload.title) return null;
+
+    let Discord;
+    try { Discord = require('discord.js'); } catch (_) { return null; }
+
+    const { EmbedBuilder } = Discord;
+    const isError = payload.status === 'error';
+
+    const embed = new EmbedBuilder()
+      .setTitle(payload.jobName || payload.title || 'SWL Notificación')
+      .setColor(isError ? 0xFF0000 : 0x00CC66)
+      .setTimestamp();
+
+    if (payload.status) {
+      embed.addFields({ name: 'Estado', value: `\`${payload.status}\``, inline: true });
+    }
+    if (payload.output) {
+      const output = payload.output.substring(0, 1000);
+      embed.addFields({ name: 'Output', value: `\`\`\`\n${output}\n\`\`\`` });
+    }
+
+    return embed;
+  }
+}
+
+module.exports = DiscordAdapter;

package/gateway/adapters/email.js

@@ -0,0 +1,221 @@
+'use strict';
+
+/**
+ * Email Adapter — Adaptador para notificaciones por correo electrónico.
+ *
+ * Soporta:
+ *   - Envío via SMTP directo (nodemailer)
+ *   - Envío via API de servicios (SendGrid, Mailgun, SES) — HTTP nativo
+ *   - Formato HTML con template básico para notificaciones
+ *   - Unidireccional (solo envío, sin recepción)
+ *
+ * Dependencia SMTP: nodemailer (npm install nodemailer)
+ * Dependencia API: ninguna (HTTP nativo)
+ *
+ * @module gateway/adapters/email
+ */
+
+const BaseAdapter = require('./base');
+const https = require('https');
+
+class EmailAdapter extends BaseAdapter {
+  constructor(config) {
+    super('email', config);
+    this._transporter = null;
+    this._mode = config.mode || 'api'; // 'smtp' | 'api'
+  }
+
+  async start() {
+    if (this._mode === 'smtp') {
+      return this._startSMTP();
+    }
+    return this._startAPI();
+  }
+
+  /**
+   * Modo SMTP con nodemailer.
+   */
+  async _startSMTP() {
+    let nodemailer;
+    try {
+      nodemailer = require('nodemailer');
+    } catch (_) {
+      console.log('[email] nodemailer no instalado. Ejecutar: npm install nodemailer');
+      return;
+    }
+
+    const host = this.config.smtpHost || process.env.SMTP_HOST;
+    const port = this.config.smtpPort || process.env.SMTP_PORT || 587;
+    const user = this.config.smtpUser || process.env.SMTP_USER;
+    const pass = this.config.smtpPass || process.env.SMTP_PASS;
+
+    if (!host || !user) {
+      console.log('[email] SMTP no configurado. Establecer SMTP_HOST y SMTP_USER.');
+      return;
+    }
+
+    this._transporter = nodemailer.createTransport({
+      host,
+      port: Number(port),
+      secure: Number(port) === 465,
+      auth: { user, pass },
+    });
+
+    this.running = true;
+    console.log(`[email] Adaptador iniciado (SMTP: ${host}:${port}).`);
+  }
+
+  /**
+   * Modo API (SendGrid, Mailgun, SES — via HTTP).
+   */
+  async _startAPI() {
+    const apiKey  = this.config.apiKey || process.env.EMAIL_API_KEY;
+    const service = this.config.service || process.env.EMAIL_SERVICE || 'sendgrid';
+
+    if (!apiKey) {
+      console.log(`[email] API key no configurada. Establecer EMAIL_API_KEY para ${service}.`);
+      return;
+    }
+
+    this._apiKey  = apiKey;
+    this._service = service;
+    this.running  = true;
+    console.log(`[email] Adaptador iniciado (API: ${service}).`);
+  }
+
+  async stop() {
+    if (this._transporter) {
+      this._transporter.close();
+      this._transporter = null;
+    }
+    this.running = false;
+    console.log('[email] Adaptador detenido.');
+  }
+
+  async send(message) {
+    const to   = message.chatId || this.config.defaultTo || process.env.EMAIL_DEFAULT_TO;
+    const from = this.config.from || process.env.EMAIL_FROM || 'swl-ses@noreply.com';
+
+    if (!to) return false;
+
+    const subject = this._buildSubject(message);
+    const html    = this._buildHTML(message);
+    const text    = this.formatMessage(message);
+
+    if (this._mode === 'smtp') {
+      return this._sendSMTP(from, to, subject, text, html);
+    }
+    return this._sendAPI(from, to, subject, text, html);
+  }
+
+  /**
+   * Envía via SMTP con nodemailer.
+   */
+  async _sendSMTP(from, to, subject, text, html) {
+    if (!this._transporter) return false;
+
+    try {
+      await this._transporter.sendMail({ from, to, subject, text, html });
+      return true;
+    } catch (err) {
+      console.error(`[email] Error SMTP: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * Envía via SendGrid API (HTTP POST).
+   */
+  async _sendAPI(from, to, subject, text, html) {
+    if (!this._apiKey) return false;
+
+    if (this._service === 'sendgrid') {
+      return this._sendSendGrid(from, to, subject, text, html);
+    }
+
+    // Fallback genérico — tratar como webhook
+    console.log(`[email] Servicio "${this._service}" no implementado. Usar "sendgrid" o modo "smtp".`);
+    return false;
+  }
+
+  /**
+   * SendGrid v3 API.
+   */
+  _sendSendGrid(from, to, subject, text, html) {
+    const body = JSON.stringify({
+      personalizations: [{ to: [{ email: to }] }],
+      from: { email: from },
+      subject,
+      content: [
+        { type: 'text/plain', value: text },
+        { type: 'text/html', value: html },
+      ],
+    });
+
+    return new Promise((resolve) => {
+      const req = https.request({
+        hostname: 'api.sendgrid.com',
+        path: '/v3/mail/send',
+        method: 'POST',
+        headers: {
+          'Authorization': `Bearer ${this._apiKey}`,
+          'Content-Type': 'application/json',
+          'Content-Length': Buffer.byteLength(body),
+        },
+        timeout: 10000,
+      }, (res) => {
+        let data = '';
+        res.on('data', chunk => data += chunk);
+        res.on('end', () => resolve(res.statusCode >= 200 && res.statusCode < 300));
+      });
+
+      req.on('error', () => resolve(false));
+      req.on('timeout', () => { req.destroy(); resolve(false); });
+      req.write(body);
+      req.end();
+    });
+  }
+
+  _buildSubject(message) {
+    const payload = message.payload || message;
+    const status  = payload.status === 'completed' ? '✓' : '✗';
+    return `[SWL] ${status} ${payload.jobName || payload.title || 'Notificación'}`;
+  }
+
+  _buildHTML(message) {
+    const payload = message.payload || message;
+    const isError = payload.status === 'error';
+    const color   = isError ? '#dc3545' : '#28a745';
+
+    return `
+<!DOCTYPE html>
+<html><body style="font-family:system-ui,sans-serif;max-width:600px;margin:0 auto;padding:20px">
+  <div style="border-left:4px solid ${color};padding:12px 16px;margin-bottom:16px">
+    <h2 style="margin:0 0 8px;color:${color}">${payload.jobName || 'SWL Notificación'}</h2>
+    <p style="margin:0;color:#666">Estado: <strong>${payload.status || 'unknown'}</strong></p>
+  </div>
+  ${payload.output ? `<pre style="background:#f5f5f5;padding:12px;border-radius:4px;overflow-x:auto;font-size:13px">${_escapeHTML(payload.output.substring(0, 2000))}</pre>` : ''}
+  <hr style="border:none;border-top:1px solid #eee;margin:20px 0">
+  <p style="color:#999;font-size:12px">Enviado por SWL-SES Gateway — ${new Date().toISOString()}</p>
+</body></html>`.trim();
+  }
+
+  formatMessage(swlMessage) {
+    const payload = swlMessage.payload || swlMessage;
+
+    if (payload.jobName) {
+      const icon = payload.status === 'completed' ? '[OK]' : '[ERROR]';
+      const lines = [`${icon} ${payload.jobName}`, `Estado: ${payload.status}`];
+      if (payload.output) lines.push('', payload.output.substring(0, 1000));
+      return lines.join('\n');
+    }
+
+    return swlMessage.text || JSON.stringify(payload).substring(0, 500);
+  }
+}
+
+function _escapeHTML(str) {
+  return str.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
+
+module.exports = EmailAdapter;