Pidrav So I think it's inevitable to have, on the unit entity: a component containing the GameObject with everything spine related and also the request of animation that is called from the execute() of a node right?

Yes, unfortunately I also see no way around it.

Pidrav As for now, do you have some insights or suggestion for the bridge ECS -> MB for changing animations?

I'm not sure what to suggest here, as you've already provided part of the implementation above. In general your approach of using something similar to command-buffers / requests seems very reasonable, having ECS AI logic adding animation-change-commands to a common request list, while at a MonoBehaviour you then process all accumulated animation-change-commands. If possible, script execution order should be setup so that the commands are processed before AnimationState.Update, so that you don't delay it by a frame. It's beneficial here that the animation shall be triggered by AI behaviour changes, so any latency here will not matter as much here (compared to latency from input to animation change).

[Edit: added section]
The only design considerations that come to my mind here are to make sure that the common animation command queue(s) are set up in a thread-friendly way as a multi-producer-single-consumer queue.
ECS might have something like this:

// on 
public NativeQueue<AnimationChangeRequest> queue;
..
var writer = queue.AsParallelWriter();

A friendly LLM generated this code for me, I'm sharing it here untested, in case it helps:

// Animation request struct that's Burst-compatible
[BurstCompile]
public struct AnimationChangeRequest : IComponentData
{
    public Entity TargetEntity;
    public int AnimationId; // Use int instead of string for Burst
    public float TimeScale;
    public bool Loop;
    public int Priority; // For sorting if needed
}

// Shared queue container
public class AnimationQueueContainer : IComponentData
{
    public NativeQueue<AnimationChangeRequest> Queue;
    
    public AnimationQueueContainer()
    {
        Queue = new NativeQueue<AnimationChangeRequest>(Allocator.Persistent);
    }
    
    public void Dispose()
    {
        if (Queue.IsCreated)
            Queue.Dispose();
    }
}

// ECS System that enqueues animation changes
[BurstCompile]
public partial struct EnqueueAnimationSystem : ISystem
{
    private NativeQueue<AnimationChangeRequest>.ParallelWriter queueWriter;
    
    public void OnCreate(ref SystemState state)
    {
        var queue = new NativeQueue<AnimationChangeRequest>(Allocator.Persistent);
        SystemAPI.SetSingleton(new AnimationQueueContainer { Queue = queue });
    }
    
    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
        var queue = SystemAPI.GetSingleton<AnimationQueueContainer>().Queue;
        var writer = queue.AsParallelWriter();
        
        state.Dependency = new EnqueueAnimationJob
        {
            QueueWriter = writer
        }.ScheduleParallel(state.Dependency);
    }
    
    [BurstCompile]
    partial struct EnqueueAnimationJob : IJobEntity
    {
        public NativeQueue<AnimationChangeRequest>.ParallelWriter QueueWriter;
        
        void Execute(Entity entity, in SpineAnimationState animState)
        {
            if (animState.HasChanged)
            {
                QueueWriter.Enqueue(new AnimationChangeRequest
                {
                    TargetEntity = entity,
                    AnimationId = animState.AnimationId,
                    TimeScale = animState.TimeScale,
                    Loop = animState.Loop
                });
            }
        }
    }
}

// MonoBehaviour consumer
public class SpineAnimationConsumer : MonoBehaviour
{
    private EntityManager entityManager;
    private NativeQueue<AnimationChangeRequest> animationQueue;
    private Dictionary<Entity, SkeletonAnimation> entityToSpine;
    
    void Start()
    {
        entityManager = World.DefaultGameObjectInjectionWorld.EntityManager;
        entityToSpine = new Dictionary<Entity, SkeletonAnimation>();
    }
    
    void Update()
    {
        // Get queue reference
        var queueContainer = entityManager.CreateEntityQuery(
            ComponentType.ReadOnly<AnimationQueueContainer>()
        ).GetSingleton<AnimationQueueContainer>();
        
        animationQueue = queueContainer.Queue;
        
        // Process all queued requests
        while (animationQueue.TryDequeue(out AnimationChangeRequest request))
        {
            ProcessAnimationRequest(request);
        }
    }
    
    void ProcessAnimationRequest(AnimationChangeRequest request)
    {
        if (entityToSpine.TryGetValue(request.TargetEntity, out var skeleton))
        {
            // Apply animation change
            var animationName = GetAnimationName(request.AnimationId);
            skeleton.AnimationState.SetAnimation(0, animationName, request.Loop);
            skeleton.timeScale = request.TimeScale;
        }
    }
}