fix(umind): auditoría de las cinco features — cinco defectos y un guard permanente

Revisión de coherencia de todo lo que entró. Cinco cosas mal, ninguna
detectable compilando:

1. LA PUERTA DE TOOLS DECIDÍA AL REVÉS. executeUmindTool encolaba antes de
   clasificar, así que en un canal público CUALQUIER nombre de herramienta
   terminaba como pendiente de aprobación — incluidos los que el modelo
   inventa y los internos, cuyos guards ("solo el dueño") quedaban
   inalcanzables porque vivían más abajo en el flujo. Un visitante del widget
   podía llenarle al dueño la bandeja de solicitudes para ejecutar cosas que
   no existen.

   Ahora se clasifica primero: lectura ejecuta, interna se rechaza si el
   pedido es público, acción se encola, desconocida se rechaza. Verificado
   inyectando la falla: el test falla y vuelve a pasar al arreglarlo.

2. El enlace "Ver el documento" de la bandeja estaba muerto: archivo_id no lo
   escribía nadie. Ahora la acción aprobada engancha el PDF que produjo.

3. Los PDF generados esquivaban la cuota de almacenamiento. El tope del plan
   se evitaba pidiéndole documentos al agente en vez de subiendo archivos.

4. La vista de Consumo no conocía el tipo "documento" — el rubro nuevo salía
   sin nombre ni color. Y el icono que le puse no existía en el set, así que
   habría quedado invisible: el mismo bug de los iconos de hace unas semanas,
   que compila y se ve vacío.

5. Las seis lecturas nuevas se registraron con w() en vez de r(), exigiendo
   SoloAdmin para leer. No era una fuga —era más estricto— pero un usuario
   staff sin admin veía la lista de agentes y 403 en sus avisos.

Y el guard que evita el próximo: TestTodoHandlerUmindValidaAlcance recorre los
65 handlers de uMind y exige que cada uno valide el alcance del tenant, o esté
en una lista de exenciones con el motivo escrito. Los mismos handlers se montan
para staff y para clientes; el middleware de scope deja los tenants permitidos
en el contexto pero no mira el :id de la URL — eso lo hace cada handler, y el
que se olvide compila igual. Al escribirlo el propio test encontró que mi lista
de exenciones sobraba en dos, y verifiqué con un handler con fuga deliberada
que lo detecta.

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

pkg/services/umind_agent_service.go

@@ -155,8 +155,23 @@ func umindEmailTools() []agentTool {
 // esperando a una persona. El trabajo real vive en ejecutarHerramienta, que es
 // lo que corre después una aprobación.
 func executeUmindTool(agenteID uint, sessionID string, sesionInterna bool, name string, args map[string]interface{}) string {
-	if RequiereAprobacion(sesionInterna, name) {
-		return EncolarAccion(agenteID, sessionID, name, args)
+	switch CategoriaTool(agenteID, name) {
+	case "desconocida":
+		// Un nombre que no existe se rechaza acá y no se encola. Si no, el
+		// modelo alucinando un nombre le llena la bandeja al dueño de
+		// solicitudes para ejecutar herramientas que nunca existieron.
+		return fmt.Sprintf(`{"error": "herramienta desconocida: %s"}`, name)
+	case "interna":
+		// Programar avisos y vigilancias gasta el plan del dueño. No se
+		// encolan para que las apruebe: desde un canal público directamente
+		// no se piden.
+		if !sesionInterna {
+			return `{"error": "eso solo puede pedirlo el dueño desde su canal privado"}`
+		}
+	case "accion":
+		if !sesionInterna {
+			return EncolarAccion(agenteID, sessionID, name, args)
+		}
 	}
 	return ejecutarHerramienta(agenteID, sessionID, sesionInterna, name, args)
 }

pkg/services/umind_aprobacion_service.go

@@ -104,6 +104,11 @@ func EjecutarAccionAprobada(accion *models.UmindAccionPendiente, quien string) e
 	if err := models.CerrarAccion(accion.ID, estado, quien, "", resultado); err != nil {
 		return err
 	}
+	// Si la acción produjo un documento, se engancha a la acción para que el
+	// que aprobó pueda abrirlo desde la misma fila donde apretó el botón.
+	if id := archivoDelResultado(resultado); id != nil {
+		models.VincularArchivoAAccion(accion.ID, *id)
+	}
 	if estado == "fallida" {
 		models.RegistrarEventoUmind(accion.AgenteID, "error", "aprobacion",
 			"Una acción aprobada falló al ejecutarse: "+accion.Resumen, resultado)
@@ -148,3 +153,39 @@ func avisarAccionPendiente(agente *models.UmindAgente, accion *models.UmindAccio
 		}
 	}
 }
+
+// CategoriaTool clasifica la llamada ANTES de decidir qué hacer con ella:
+//
+//	lectura     — no sale nada del negocio, se ejecuta siempre
+//	interna     — gasta el plan del dueño, solo desde su canal privado
+//	accion      — sale hacia afuera, espera aprobación si el pedido es público
+//	desconocida — el nombre no existe: se rechaza, nunca se encola
+//
+// La clasificación existe porque sin ella todo lo que no fuera lectura se
+// encolaba, incluidos los nombres que el modelo inventa.
+func CategoriaTool(agenteID uint, name string) string {
+	switch name {
+	case "buscar_conocimiento", "leer_bandeja":
+		return "lectura"
+	case "programar_aviso", "listar_avisos", "cancelar_aviso",
+		"crear_vigilancia", "listar_vigilancias", "cancelar_vigilancia":
+		return "interna"
+	case "enviar_correo", "generar_documento":
+		return "accion"
+	}
+	if _, err := models.GetUmindHerramientaByNombre(agenteID, name); err == nil {
+		return "accion"
+	}
+	return "desconocida"
+}
+
+// archivoDelResultado saca el archivo_id que devuelve generar_documento.
+func archivoDelResultado(resultado string) *uint {
+	var r struct {
+		ArchivoID uint `json:"archivo_id"`
+	}
+	if err := json.Unmarshal([]byte(resultado), &r); err != nil || r.ArchivoID == 0 {
+		return nil
+	}
+	return &r.ArchivoID
+}

pkg/services/umind_aprobacion_test.go

@@ -82,3 +82,59 @@ func TestAccionAprobadaUsaElPayloadGuardado(t *testing.T) {
 		t.Error("falta el reclamo: sin él, dos aprobaciones simultáneas ejecutan dos veces")
 	}
 }
+
+// La clasificación es lo que decide entre ejecutar, encolar y rechazar. Sin
+// ella, todo lo que no fuera lectura se encolaba —incluidos los nombres que el
+// modelo inventa—, y la bandeja del dueño se llenaba de solicitudes para
+// ejecutar herramientas que nunca existieron.
+func TestCategoriaTool(t *testing.T) {
+	casos := map[string]string{
+		"buscar_conocimiento": "lectura",
+		"leer_bandeja":        "lectura",
+		"programar_aviso":     "interna",
+		"cancelar_aviso":      "interna",
+		"listar_avisos":       "interna",
+		"crear_vigilancia":    "interna",
+		"listar_vigilancias":  "interna",
+		"enviar_correo":       "accion",
+		"generar_documento":   "accion",
+	}
+	for tool, quiero := range casos {
+		// agenteID 0: las tools con nombre fijo no consultan la base.
+		if got := CategoriaTool(0, tool); got != quiero {
+			t.Errorf("CategoriaTool(%q) = %q, quiero %q", tool, got, quiero)
+		}
+	}
+}
+
+// El camino completo desde un canal público, que es donde escribe cualquiera.
+func TestPuertaDeToolsDesdeCanalPublico(t *testing.T) {
+	b, err := os.ReadFile("umind_agent_service.go")
+	if err != nil {
+		t.Fatal(err)
+	}
+	s := string(b)
+	i := strings.Index(s, "func executeUmindTool")
+	cuerpo := s[i:]
+	cuerpo = cuerpo[:strings.Index(cuerpo, "\nfunc ejecutarHerramienta")]
+
+	// La clasificación tiene que decidir ANTES de encolar.
+	cat := strings.Index(cuerpo, "CategoriaTool")
+	enc := strings.Index(cuerpo, "EncolarAccion")
+	if cat < 0 || enc < 0 || cat > enc {
+		t.Fatal("la clasificación tiene que ir antes de encolar")
+	}
+	// Un nombre inexistente se rechaza, no se encola.
+	desc := cuerpo[strings.Index(cuerpo, `case "desconocida":`):strings.Index(cuerpo, `case "interna":`)]
+	if strings.Contains(desc, "EncolarAccion") {
+		t.Error("una herramienta desconocida no puede encolarse")
+	}
+	// Las internas se rechazan desde un canal público, no se encolan.
+	inter := cuerpo[strings.Index(cuerpo, `case "interna":`):strings.Index(cuerpo, `case "accion":`)]
+	if strings.Contains(inter, "EncolarAccion") {
+		t.Error("las tools internas no pueden encolarse desde un canal público")
+	}
+	if !strings.Contains(inter, "!sesionInterna") {
+		t.Error("falta el rechazo de tools internas en canal público")
+	}
+}

pkg/services/umind_documento_tools.go

@@ -116,6 +116,11 @@ func renderPDFDesdePlantilla(contenidoHTML string, datos map[string]interface{})
 // guardarPDFEnRepositorio deja el documento en los archivos del espacio, para
 // que quede a la vista y descargable como cualquier otro.
 func guardarPDFEnRepositorio(tenantID uint, nombreBase string, pdf []byte) (*models.UmindArchivo, error) {
+	// Un PDF generado ocupa lo mismo que uno subido: si no contara para la
+	// cuota, el tope del plan se esquivaría pidiéndole documentos al agente.
+	if err := models.HayEspacioUmind(tenantID, int64(len(pdf))); err != nil {
+		return nil, err
+	}
 	dir := filepath.Join("uploads", "umind", strconv.FormatUint(uint64(tenantID), 10))
 	if err := os.MkdirAll(dir, 0o755); err != nil {
 		return nil, err