feat(umind): el correo entra al agente por dos puertas distintas — y son distintas a propósito

En "Dónde atiende", el canal correo: el agente lee una casilla y responde solo
los correos que llegan, con su base de conocimiento, igual que atiende WhatsApp.
Como el correo no tiene webhook, se revisa por intervalo — y el intervalo lo
elige el cliente por canal (2 a 60 minutos): una inmobiliaria quiere 2, a un
estudio contable con 30 le sobra. El cron corre cada minuto pero cada casilla
se revisa solo cuando le toca, con un pool de 8 para que 100 casillas no salgan
a la red en el mismo instante.

Las guardas que separan "asistente" de "incidente", cada una con su test:
nunca responde correo automático ni se responde a sí mismo (el bucle con otro
autoresponder); la revisión se marca ANTES de conectar, así una contraseña
cambiada no martilla el login cada minuto hasta que el host del cliente nos
bloquea; y el correo se marca leído recién cuando la respuesta salió — si el
envío falla, queda sin leer y se reintenta.

En "Lo que sabe", las cuentas de correo: casillas que el agente consulta a
pedido — "revisame los correos de hoy y haceme un resumen" — sin nada de fondo.
Solo lectura en serio: Peek, INBOX en read-only, y un test que falla si alguien
le agrega un marcado. Ahora se pueden conectar varias por agente; con más de
una, el modelo pregunta cuál en vez de adivinar — resumirle a alguien la
casilla que no pidió no es un error menor. El alta pide correo y contraseña:
el host se deduce (mail.<dominio>) y el campo técnico aparece recién si eso
falla. Se prueba la conexión antes de guardar, con la persona mirando.

Enviar por una cuenta conectada está bloqueado a propósito: para responder
correos está el canal, con sus guardas. Una tool de envío sin límites es una
máquina de spam con el dominio del cliente.

La navegación acompaña: "Lo que sabe" agrupa Información, Cuentas de correo y
Herramientas — tres formas de saber, no tres pantallas sueltas — y Avanzado
queda solo con Problemas.

El SMTP se unificó en una sola implementación que comparten soporte y el canal:
el bug de STARTTLS que abría dos conexiones ya se pagó una vez.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

pkg/services/smtp_envio.go

@@ -0,0 +1,93 @@
+package services
+
+import (
+	"crypto/tls"
+	"fmt"
+	"net/smtp"
+	"strings"
+)
+
+// DatosSMTP es lo mínimo para mandar un correo por el servidor de cualquiera:
+// lo usa el buzón de soporte con su configuración y el canal de correo de un
+// agente con las credenciales del cliente. Una sola implementación — el bug de
+// STARTTLS que abría dos conexiones ya se pagó una vez.
+type DatosSMTP struct {
+	Host        string
+	Puerto      int
+	Encriptado  string // ssl | tls | starttls | none
+	Usuario     string
+	Password    string
+	Desde       string
+	DesdeNombre string
+}
+
+// EnviarPorSMTP abre una sola conexión, la asegura según la configuración,
+// manda el mensaje y cierra con QUIT.
+func EnviarPorSMTP(d DatosSMTP, para, asunto, cuerpoHTML string) error {
+	if d.Host == "" || d.Desde == "" || para == "" {
+		return fmt.Errorf("faltan datos para el envío (servidor, remitente o destinatario)")
+	}
+	puerto := d.Puerto
+	if puerto == 0 {
+		puerto = 587
+	}
+	nombre := d.DesdeNombre
+	if nombre == "" {
+		nombre = d.Desde
+	}
+	addr := fmt.Sprintf("%s:%d", d.Host, puerto)
+	msg := []byte(fmt.Sprintf(
+		"From: %s <%s>\r\nTo: %s\r\nSubject: %s\r\nMIME-Version: 1.0\r\nContent-Type: text/html; charset=UTF-8\r\n\r\n%s",
+		nombre, d.Desde, para, asunto, cuerpoHTML))
+
+	enc := strings.ToLower(strings.TrimSpace(d.Encriptado))
+
+	var cliente *smtp.Client
+	var err error
+	if enc == "tls" || enc == "ssl" {
+		conn, errDial := tls.Dial("tcp", addr, &tls.Config{ServerName: d.Host})
+		if errDial != nil {
+			return fmt.Errorf("no se pudo conectar por TLS: %w", errDial)
+		}
+		cliente, err = smtp.NewClient(conn, d.Host)
+		if err != nil {
+			conn.Close()
+			return fmt.Errorf("saludo SMTP rechazado: %w", err)
+		}
+	} else {
+		cliente, err = smtp.Dial(addr)
+		if err != nil {
+			return fmt.Errorf("no se pudo conectar: %w", err)
+		}
+		if enc != "none" {
+			if err := cliente.StartTLS(&tls.Config{ServerName: d.Host}); err != nil {
+				cliente.Close()
+				return fmt.Errorf("STARTTLS rechazado: %w", err)
+			}
+		}
+	}
+	defer cliente.Close()
+
+	if d.Usuario != "" {
+		if err := cliente.Auth(smtp.PlainAuth("", d.Usuario, d.Password, d.Host)); err != nil {
+			return fmt.Errorf("autenticación rechazada para %s: %w", d.Usuario, err)
+		}
+	}
+	if err := cliente.Mail(d.Desde); err != nil {
+		return fmt.Errorf("el servidor rechazó el remitente %s: %w", d.Desde, err)
+	}
+	if err := cliente.Rcpt(para); err != nil {
+		return fmt.Errorf("el servidor rechazó el destinatario %s: %w", para, err)
+	}
+	w, err := cliente.Data()
+	if err != nil {
+		return err
+	}
+	if _, err := w.Write(msg); err != nil {
+		return err
+	}
+	if err := w.Close(); err != nil {
+		return fmt.Errorf("el servidor rechazó el mensaje: %w", err)
+	}
+	return cliente.Quit()
+}