Trailing Stop Loss does not change when I'm in profit

Hi All, 

   Inside my cBot, I can't modify the TrailingStopLoss from the initial parameter given by the user to a new parameter when the position is above of my entry price certain amount of pips. Here you can see the code. 

  The Trailing Stop Loss is activated correctly but when the price is above the trigger, the trailing stop loss does not change.

Any help is really appreciated!

using cAlgo.API;
using cAlgo.API.Indicators;
using cAlgo.API.Internals;
using System;
namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.None, AddIndicators = true)]
    public class MacdCrossOverSample : Robot
    {
    
    
    
        private double _volumeInUnits;
        private MacdCrossOver _macdCrossOver;
        private ExponentialMovingAverage signalEMA;

        [Parameter("Volume (Lots)", DefaultValue = 1)]
        public double VolumeInLots { get; set; }

        [Parameter("Take Profit (Pips)", DefaultValue = 10, MaxValue = 1000, MinValue = 1, Step = 1)]
        public double TakeProfitInPips { get; set; }

        [Parameter("Label", DefaultValue = "MacdCrossOverSample")]
        public string Label { get; set; }

        [Parameter("Source", Group = "Macd Crossover")]
        public DataSeries Source { get; set; }

        [Parameter("Long Cycle", DefaultValue = 26, Group = "Macd Crossover", MinValue = 1)]
        public int LongCycle { get; set; }

        [Parameter("Short Cycle", DefaultValue = 12, Group = "Macd Crossover", MinValue = 1)]
        public int ShortCycle { get; set; }

        [Parameter("Signal Periods", DefaultValue = 9, Group = "Macd Crossover", MinValue = 1)]
        public int SignalPeriods { get; set; }

        [Parameter("EMA", DefaultValue = 9)]
        public int EMALength { get; set; }

        [Parameter("Include Trailing Stop", DefaultValue = true)]
        public bool IncludeTrailingStop { get; set; }
        
        [Parameter("Stop Trigger (pips)", DefaultValue = 20)]
        public int TrailingStopTrigger { get; set; }

        [Parameter("Stop Step (pips)", DefaultValue = 10)]
        public int TrailingStopStep { get; set; }

        [Parameter("Trailing Stop Inicial", DefaultValue = 10)]
        public int TrailingStopInicial { get; set; }


        public Position[] BotPositions => Positions.FindAll(Label);



        [Parameter("Start Hour", DefaultValue = 11)]
        public int StartHour { get; set; }

        [Parameter("End Hour", DefaultValue = 20)]
        public int EndHour { get; set; }
        
        
        protected override void OnStart()
        {
            _volumeInUnits = Symbol.QuantityToVolumeInUnits(VolumeInLots);
            _macdCrossOver = Indicators.MacdCrossOver(Source, LongCycle, ShortCycle, SignalPeriods);
            signalEMA = Indicators.ExponentialMovingAverage(Bars.ClosePrices, EMALength);
        }

        
      
        
        protected override void OnBarClosed()
        {
            
            // Verificar el horario del servidor
            DateTime serverTime = Server.Time;
            int currentHour = serverTime.Hour;
            
            if (currentHour < StartHour || currentHour >= EndHour)
            {
                Print("Fuera del horario de operación: {0} UTC", serverTime);
                return; // No operar fuera del horario
            }
            
            double price = Bars.ClosePrices.LastValue;
            double mafast = signalEMA.Result.LastValue;
            

            if (Positions.Count > 0) return;
            if (_macdCrossOver.MACD.Last(0) > _macdCrossOver.Signal.Last(0) && _macdCrossOver.MACD.Last(1) <= _macdCrossOver.Signal.Last(1) && price > mafast)
            {
                              
                
                var position = ExecuteMarketOrder(TradeType.Buy, SymbolName, VolumeInLots, null, TrailingStopInicial,TakeProfitInPips);
                position.Position.ModifyTrailingStop(true);
               
            }         
                     
            }
           
             protected override void OnTick()
            {
                if (IncludeTrailingStop)
                {
                SetTrailingStop();
                }
               }
            private void SetTrailingStop()
            {
            var buyPositions = Positions.FindAll(Label, SymbolName, TradeType.Buy);
            
            foreach (var position in buyPositions)
            {
            double distance = Symbol.Bid - position.EntryPrice;
            if (distance < TrailingStopTrigger * Symbol.PipSize)
                continue;
            double newStopLossPrice = Symbol.Bid - TrailingStopStep * Symbol.PipSize;
            
            if (newStopLossPrice> position.StopLoss)
            
            {
            position.ModifyStopLossPips(newStopLossPrice);
            }

            }
            
            }
            
            }    
            }