Why-running-strategy-monitor-before-close-does-not-produce-signals

The log explains what's happening. At 14:56, the Strategy Monitor loaded WealthData and all of the Daily histories ended on 9/18:

GLD 3449 bars to 9/18/2026 | WealthData
DIA 3448 bars to 9/18/2026 | WealthData
...
NVDA 3449 bars to 9/18/2026 | WealthData

So when the Strategy ran at 14:56, there was no 9/21 Daily bar yet for it to evaluate. Running it manually again at 14:58 didn't help because the underlying data still hadn't changed.

After the market closed, WealthData published the completed 9/21 Daily bars, which you can see when you restarted at 15:03:

GLD 3450 bars to 9/21/2026 | WealthData
...
NVDA 3450 bars to 9/21/2026 | WealthData

That's why the backtest could produce the signals after the close.

Running the strategy manually from the SM does not trigger At-Close Signal processing, you'd need to let that happen on its own at the configured time.

It was a failed test because you Activated the Strategy item too close to the run time - 250 seconds before the close is 14:55:50.

You'll see that in the first block of the log, GetHistories didn't finish until 14:56:12...
9/21/2026 14:56:12: GetHistories returned with 22 symbols

At 14:56:12, Next Run was set to 14:55:00
That Next Run started immediately, but since it was already inside the "window" of an AtClose run, it runs as normal processing, by design.

If it were an At-Close Processing run, you'd see "Collecting Partial Bars..." in the log.

What is a practical guideline for a time to activate the Strategy Monitor before the intended At‑Close run window (say seconds before close = 250 or 600 ) ?

Practically, just do it once and save it in your Workspace. Then you aren't rushing to Activate something that could have been done 7 hours before.

If the question is how long do you need to complete the process before the close, it depends on the provider and the number of symbols. Do a test and see how it takes to "Collect Partial Bars". As a rule of thumb you can start with 2 symbols per second, so you'd need about 1 minute for 100 symbols.

Per yours - "SM does not trigger At-Close Signal processing, you'd need to let that happen on its own at the configured time" - means Partial or Daily bars form at the configured time = XX seconds before close ? Is this a method to form Partial or Daily bars for Today before close for Strategy evaluation?

Partial bars are returned from real-time providers for history requests whenever the market is open. Those requests go out when the Run starts N seconds before the close.

Thanks,
I'll change Monitor strategy streaming from Yahoo to Tingo - to provide real time and get Partial bars before closing.

WealthData also returns partial bars, assuming your symbols are all in the S&P 500.

QUOTE:
I'll change Monitor strategy streaming ..

The Streaming Provider does not matter here. It's the checked Historical Provider highest in the list that returns [partial] daily bars. WealthData works for that (SP500, N100, and many ETF), but a WealthData partial bar prices could be delayed by a couple minutes. Yahoo! partial bars may be more up-to-date (NLS pricing).

Who's your broker?
With only 22 symbols as indicated in your log, even IB would work well for this.

For testing - using Dummy broker.
Here is the latest test log - however no Partial bars getting there -

9/23/2026 10:48:30: Status = LoadingData
9/23/2026 10:48:30: Start Polling Thread
9/23/2026 10:48:30: Populating Data
9/23/2026 10:48:30: Calling GetHistories Pass 1
9/23/2026 10:48:30: GetHistories returned with 21 symbols
9/23/2026 10:48:30: Calling GetHistories Pass 2
9/23/2026 10:48:31: GetHistories returned with 21 symbols
9/23/2026 10:48:31: GLD 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: DIA 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: GEV 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: AMD 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: AMAT 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: QQQ 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: RSP 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: SOXX 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: SPY 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: NOW 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: CVX 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: XLU 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: XLE 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: NVDA 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: PFE 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: META 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: MSFT 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: GOOGL 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: AMZN 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: AAPL 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: TSM 64 bars to 9/22/2026 | Yahoo! Finance
9/23/2026 10:48:31: NextRun set to 9/23/2026 14:00
9/23/2026 10:48:31: Status = Idle

Just like for all tools, partial bars are ignored, discarded for regular runs.

Remember where we're trying to do here: get an estimate of the Daily bar before the close.. when At-Close Process runs. I don't think you can even schedule that more than 1/2 hour before the close.

In yesterday’s testing I tried both 1800 seconds and 600 seconds before the close, but no partial bars were generated. Since partial bars are important as a proxy for the final daily bar, I’m submitting a feature request to test/support this capability.

Thanks for considering it.
#FeatureRequest

We use this feature every day. It works.

How did you test for partial bars? They don't show up in the log, but you can collect evidence by exporting the bars object during the At Close run.

So, partial bars don't show up in the Strategy monitor log by design but generated to participate at-close signaling. To test the bars object during the At Close run
do I need to create bars export method as part of strategy script in c# ?

You WILL see a message in the SM log when partial bars are being requested and delivered.

No signals generated at-close for testing strategy ( buy open, sell close).
Please see/advise on following results.

Thanks

Monitor settings,



Log without Partial bars,
9/24/2026 14:49:57: Status = LoadingData
9/24/2026 14:49:57: Start Polling Thread
9/24/2026 14:49:57: Populating Data
9/24/2026 14:49:57: Calling GetHistories Pass 1
9/24/2026 14:49:58: GetHistories returned with 21 symbols
9/24/2026 14:49:58: Calling GetHistories Pass 2
9/24/2026 14:49:58: GetHistories returned with 21 symbols
9/24/2026 14:49:58: GLD 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: DIA 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: MRNA 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: GEV 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: QQQ 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: RSP 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: SOXX 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: SPY 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: PFE 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: XLE 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: XLU 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: NVDA 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: AMAT 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: AMD 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: GOOGL 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: MSFT 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: CVX 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: AMZN 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: META 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: TSM 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: AAPL 64 bars to 9/23/2026 | Yahoo! Finance
9/24/2026 14:49:58: NextRun set to 9/24/2026 14:55
9/24/2026 14:49:58: Status = Idle
9/24/2026 14:55:01: Status = Processing
9/24/2026 14:55:03: Ran Strategy on GEV,DIA,GLD,RSP,MRNA,XLE,PFE,SOXX,QQQ,SPY,XLU,AMD,NVDA,AMZN,AMAT,TSM,GOOGL,CVX,META,AAPL,MSFT: 0 Signals, Run Time=267ms
9/24/2026 14:55:03: NextRun set to 9/24/2026 18:00
9/24/2026 14:55:03: Status = Completed
9/24/2026 14:55:03: Processed all Symbols

File Output run as part of testing strategy and having Partial bars for AAPL and other symbols
Date,Open,High,Low,Close,Volume
2026-06-24,295.36,299.70,292.94,293.08,53081900
...
2026-09-23,341.08,341.80,335.50,337.02,31587800
2026-09-24,336.32,338.91,334.30,336.73,17560317

To me, it looks like it worked perfectly. The close of the 1-minute bar on 9/24/2026 for AAPL at 15:55:00 ET (based on the log, it looks like you're in CST) was 336.73, as your data shows as the last bar's partial Daily close. High and Low for the day are correct too (Open is debatable).

If you didn't get a signal, one of these must be true:
a. the script doesn't have a MarketClose signal, or,
b. the script's logic didn't trigger the MarketClose signal, or,
c. it's not programmed correctly to trigger the signal on an At-Close run.

If you can't figure it out, we'd be happy to review your test script.

By the way, the message "Collecting Partial Bars..." actually shows up in the Status column, not in the log.

Thanks Cone, I’m going to add this to the log as well.

Please see the Execute script

public override void Execute(BarHistory bars, int idx)
{
if (!HasOpenPosition(bars, PositionType.Long))
{
PlaceTrade(bars, TransactionType.Buy, OrderType.Market, bars.Open[idx]);
}
else
{
PlaceTrade(bars, TransactionType.Sell, OrderType.Market, bars.Close[idx]);
}
}

Both orders are OrderType.Market.

At-Close Processing ONLY acts on orders for OrderType.MarketClose. When a MarketClose signal triggers during an At-Close Processing run, it will be converted to a Market order.

Please watch this video about how to set up and use At-Close processing and its purpose in a strategy:
https://www.youtube.com/watch?v=Z39A55OEudM

Yes, using Ordertype.Marketclose - generated testing signals.
And as Per Glitch to “add this to the log as well” - going to be much beneficial refinement.

Thanks!

It will be in Build 11, the next upcoming release.

Thanks,
Adding at-close prices to SM log would help.

In SM testing got 4 signals today with proper at-close prices retrieved in SM at 2 pm.
However, signals were reported as of yesterday 9/29 along with their Closing prices. Wonder is this is expected behavior. See below.

Sure (and the market isn't closed today). To get an At-Close signal, the MarketClose signal MUST occur on the previous (yesterday's) bar for the order to be processed at the close "today".

Remember, we're adding the partial bar to the BarHistory to allow the script to calculate indicators at the "estimated close of today" so that you can create rules like, if (bars.Close[idx + 1] < sma200[idx + 1]) then sell at the close, tomorrow (which is today). That signal occurred on yesterday's bar, but couldn't be processed without today's [estimated] closing price, which happens before the close!

Wonder why in testing today's MarketClose signals occurring on yesterday bar are mismatching execution log showing different buy/close.
Are such difference is expected or it's a problem?

Here is the execution log showing CVX buy, XLE sell

2026-10-05 14:10:02 10/5/2026 12:00:00 AM ind 24 CVX BUY RotateIn closing price 206.39
2026-10-05 14:10:02 10/5/2026 12:00:00 AM ind 24 XLE Sell RotateOut closing price 63.41

However, Signals showing buy XLE, sell AMZN


and execution code
public override void Execute(BarHistory bars, int idx)
{
double closePrice = bars.Close[idx]; Transaction t;
bool inBuyList = buys.Contains(bars);
if (!HasOpenPosition(bars, PositionType.Long))
{
if (inBuyList)
{
PlaceTrade(bars, TransactionType.Buy, OrderType.MarketClose, 0, "RotateIn");
if (idx == bars.Count-1 ) WriteToDebugLog(bars.DateTimes[idx] + " ind " + idx + " "+ bars.Symbol + " BUY RotateIn" + " closing price " + closePrice);
if (idx == bars.Count-1 ) Log(bars.DateTimes[idx] + " ind " + idx + " "+ bars.Symbol + " BUY RotateIn" + " closing price " + closePrice);
}
}
else ...

The MarketClose run is performed on a temporary daily bat that is composed based on the partial bar data generated by the provider. It should match the signals generated by the penultimate daily bar, not the most recent one, once the end of data data comes in and the current day bar is available.

So signals vs log mismatch because signals generate on full (yesterday) bar,
but log comes from partial (today) bar and there is no way to match it ?

Buy CVX, Sell XLE are signals from last Friday (Signal Date 10/2/2026) that executed at this morning's open at market.

An At-Close run today are the signals that will occur at MarketClose today: Buy XLE, Sell AMZN... or presumably tomorrow morning (I don't really know what you're trying to do).

Anyway, since the close can be different, it's always possible that signals based on partial bars won't match the settled bars.

What about Execution log running at-close today 14:10:02 and showing CVX buy, XLE sell - does it perform on Partial bar ?
See below-

2026-10-05 14:10:02 10/5/2026 12:00:00 AM ind 24 CVX BUY RotateIn closing price 206.39
2026-10-05 14:10:02 10/5/2026 12:00:00 AM ind 24 XLE Sell RotateOut closing price 63.41

As I suspected, I don't know what you're doing, but I'd be happy to review the complete test script.

The code in Post #25 doesn't set up an example of a script that uses At-Close processing to perform a trading action on "today's close".
It's normal logic to do something at tomorrow's close ... but it will occur today if you run it before the close. This won't match the backtest because after the market closes, you'll get a signal to perform that action at Market Close tomorrow.

Here's a simple example of a backtest set up properly for an At-Close order. See the comments for clues. The key coding pattern is to not process the final bar for a MarketClose order that you want to happen "today".

CODE:
using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using System.Collections.Generic;

namespace WealthScript123
{
    public class AtCloseDemo : UserStrategyBase
    {   
        public override void Initialize(BarHistory bars)
        {
         StartIndex = 1;
        }

      public override void Execute(BarHistory bars, int idx)
      {
         Position p = LastOpenPosition;
         if (p != null)
         {
            // if a Position is open close it tomorrow at market
            ClosePosition(p, OrderType.Market);
         }
         
         // NO SIGNALING to buy at close on the last bar because we're peeking
         if (idx >= bars.Count - 1)
            return;

         // Buy if tomorrow's close is 1% greater than today's close
         if (bars.Close[idx + 1] > bars.Close[idx] * 1.01)
         {
            //buy at MarketClose tomorrow - signals always execute on the next bar
            PlaceTrade(bars, TransactionType.Buy, OrderType.MarketClose);
         }
      }
    }
}

Run the script on a symbol like SPY.
Move the mouse across the chart.
You'll see that on every bar where CHG is 1.00% or greater, there will be a buy at the close.
That will happen on an At-Close run today too, if the partial bar's close is 1% above Monday's close.

Please see my script with your suggestions included for both backtesting and SM processing to test.
Probably should I set StartIndex = 14 since using RSI ?

CODE:
using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;
using WealthLab.DeepLearning;
using System.IO;


namespace WealthScript6 
{
   public class ParticipantsRankRsi : UserStrategyBase
   {
      //the list of symbols that we should buy each bar
      private static List<BarHistory> buys = new List<BarHistory>();
      int PSize, TypeIND;
      DateTime cutoff;
      private int pLiveMode;
      private bool live;

      //create the weight indicator and stash it into the BarHistory object for reference in PreExecute
      public ParticipantsRankRsi()
      {
         AddParameter("PSize", ParameterType.Int32, 15, 0, 20, 1);
         AddParameter("Rsi Macd", ParameterType.Int32, 0, 0, 1, 1);
         AddParameter("pLiveMode", ParameterType.Int32, 0, 0, 1, 1);
      }


      public override void Initialize(BarHistory bars)
      {
         PSize = Parameters[0].AsInt;
         TypeIND = Parameters[1].AsInt;
         pLiveMode = Parameters[2].AsInt;            
         live = (pLiveMode == 1);

StartIndex = 1;  //per Cone - skipping
         if (TypeIND == 0)
         {
            ind = new RSI(bars.Close, 14);
         }
         else if (TypeIND == 1)
         { 
            ind = new MACDHist(bars.Close, 12, 26, 9);
         }
         bars.Cache["IND"] = ind;

         PlotIndicator(ind, WLColor.Red);

         cutoff = DateTime.Today.AddDays(-3);
         string folder = @"C:\Users\landa\AppData\Roaming\WealthLab9\debug";
         Directory.CreateDirectory(folder);
         string todayFile = Path.Combine(folder, $"Rotation_{DateTime.Now:yyyyMMdd}.txt");
         if (File.Exists(todayFile))   File.Delete(todayFile);
      }

      //this is called prior to the Execute loop, determine which symbols have the lowest RSI
      public override void PreExecute(DateTime dt, List<BarHistory> participants)
      {
         //store the symbols' RSI value in their BarHistory instances
         foreach (BarHistory bh in participants)
         {
            int idx = GetCurrentIndex(bh);  //this returns the index of the BarHistory for the bar currently being processed
            TimeSeries tind = (TimeSeries)bh.Cache["IND"];  //CustomNPE npe = (CustomNPE)bh.Cache["NPE"];
            double Val = tind[idx];
            bh.UserData = Val; //save the current NPE value along with the BarHistory instance            
         }

         //sort the participants by RSI value (lowest to highest)
         participants.Sort((a, b) => a.UserDataAsDouble.CompareTo(b.UserDataAsDouble));

         //keep the top symbols
         buys.Clear();
         for (int n = 0; n < PSize; n++)
         {
            if (n >= participants.Count)
               break;

            int j = participants[n].IndexOf(dt, false);
            double closePrice = participants[n].Close[j];
            double Weight = participants[n].UserDataAsDouble;
            buys.Add(participants[n]);
            if (dt >= cutoff)
            {
               WriteToDebugLog(dt.Date + " ind "+ j + " PreExecute " +  participants[n].Symbol 
                  + " weight " + Weight + " close " + closePrice);
               Log(dt.Date + " ind " + j + " PreExecute " +  participants[n].Symbol + " weight " + Weight + " close " + closePrice);
            }

         }
      }

      //execute the strategy rules here, this is executed once for each bar in the backtest history
      public override void Execute(BarHistory bars, int idx)
      {
           // Skip final bar for MarketClose orders (per Cone rule)
            if (idx >= bars.Count - 1)
                return;         

                        double closePrice = bars.Close[idx];
         Transaction t;
         bool inBuyList = buys.Contains(bars);
         if (!HasOpenPosition(bars, PositionType.Long))
         {
            //buy logic - buy if it's in the buys list
            if (inBuyList)
            {
               if (live) t = PlaceTrade(bars, TransactionType.Buy, OrderType.MarketClose, 0, "RotateIn");
               else t = PlaceTrade(bars, TransactionType.Buy, OrderType.Market, 0, "RotateIn");
               t.Weight = Math.Max(1, 100 - ind[idx]);
               if (idx == bars.Count-1 ) WriteToDebugLog(bars.DateTimes[idx] + " ind " + idx +  " "+ bars.Symbol + " BUY RotateIn" + " closing price " + Math.Round(closePrice, 2).ToString());
               if (idx == bars.Count-1 ) Log(bars.DateTimes[idx] + " ind " + idx +  " "+ bars.Symbol + " BUY RotateIn" + " closing price " + Math.Round(closePrice, 2).ToString());
            }
         }
         else
         {
            //sell logic, sell if it's not in the buys list
            if (!inBuyList)
            {
               if (live) t = PlaceTrade(bars, TransactionType.Sell, OrderType.MarketClose, 0, "RotateOut");
               else t = PlaceTrade(bars, TransactionType.Sell, OrderType.Market, 0, "RotateOut");
               t.Weight = Math.Max(1, 100 - ind[idx]);
               if (idx == bars.Count-1 ) WriteToDebugLog(bars.DateTimes[idx] + " ind " + idx + " " + bars.Symbol + " Sell RotateOut" + " closing price " + Math.Round(closePrice, 2).ToString());
               if (idx == bars.Count-1 ) Log(bars.DateTimes[idx] + " ind " + idx + " " + bars.Symbol + " Sell RotateOut" + " closing price " + Math.Round(closePrice, 2).ToString());
            }
         }
      }

      void Log(string msg)
      {
         string folder = @"C:\Users\landa\AppData\Roaming\WealthLab9\debug";
         Directory.CreateDirectory(folder);

         DateTime now = DateTime.Now;
         string todayFile = Path.Combine(folder, $"Rotation_{now:yyyyMMdd}.txt");

         File.AppendAllText(todayFile, $"{now:yyyy-MM-dd HH:mm:ss} {msg}\n");       }

      //declare private variables below
      private IndicatorBase ind;
   }
}

For a 14 period RSI, I'd use this:

CODE:
StartIndex = 14 * 3;

Explain the purpose of LiveMode.
Is it that you just want a switch to see the difference between backtests that perform the rotation at MOC and MOO?

Yes - LiveMode parameter to see backtest vs SM difference.

But Why startindex for RSI or MACD = 14*3 ?
And Settings data range could be set 1 or more for SM testing ?

Live mode (and if it the strategy really supported it correctly) switches the order types to MarketClose. That will always be different from using Market orders that fill at the open of the next bar.

If you want to run a regular rotation strategy - even in the S. Monitor - and change positions at market open, there's absolutely no need for the "Live Mode" and MarketClose orders. That's understood, right?

The purpose of "Live Mode" as I see it, is to see the difference between backtests that perform the rotation at MOC and MOO. That would be an interesting test!

QUOTE:
But Why startindex for RSI or MACD = 14*3 ?

User Guide (F1) > Indicators > Stability of Indicators

QUOTE:
And Settings data range could be set 1 or more for SM testing ?

One or more what? You need to set the data range for the indicators to be valid (14 * 3 bars) plus a minimum of the longest period of time you expect to hold a position. For a Daily strategy like this, just use 200 or more bars without any worries.

Thank you very much for your guidance on this —
it worked exactly as advertised.

Here's your script with the "At-Close" rotation properly programmed. It corresponds to the switch to "Live Mode" - sort of a misnomer for this purpose.

The resulting difference between an At-Close and On-Open rotation is quite stark in the small test I did with the Dow 30. Worth looking into further!

CODE:
using WealthLab.Backtest;
using System;
using WealthLab.Core;
using WealthLab.Indicators;
using WealthLab.ChartWPF;
using System.Drawing;
using System.Collections.Generic;
using System.IO;

namespace WealthScript3 
{
   public class ParticipantsRankRsi : UserStrategyBase
   {
      //the list of symbols that we should buy each bar
      private static List<BarHistory> buys = new List<BarHistory>();
      int PSize, TypeIND;
      DateTime cutoff;
      private bool live;      
      string folder;

      //create the weight indicator and stash it into the BarHistory object for reference in PreExecute
      public ParticipantsRankRsi()
      {
         AddParameter("PSize", ParameterType.Int32, 15, 0, 20, 1);
         AddParameter("Rsi Macd", ParameterType.Int32, 0, 0, 1, 1);
         AddParameter("LiveMode=1", ParameterType.Int32, 0, 0, 1, 1);
      }


      public override void Initialize(BarHistory bars)
      {
         PSize = Parameters[0].AsInt;
         TypeIND = Parameters[1].AsInt;         
         live = (Parameters[2].AsInt == 1);

         if (TypeIND == 0)
         {
            ind = new RSI(bars.Close, 14);
         }
         else if (TypeIND == 1)
         {
            ind = new MACDHist(bars.Close, 12, 26, 9);
         }
         bars.Cache["IND"] = ind;

         PlotIndicator(ind, WLColor.Red);

         cutoff = DateTime.Today.AddDays(-7);
         folder = Path.Join(WLHost.Instance.DataFolder, "debug");
         Directory.CreateDirectory(folder);
         string todayFile = Path.Combine(folder, $"Rotation_{DateTime.Now:yyyyMMdd}.txt");
         if (File.Exists(todayFile)) File.Delete(todayFile);

         StartIndex = 14 * 3;
      }

      //this is called prior to the Execute loop, determine which symbols have the lowest RSI
      public override void PreExecute(DateTime dt, List<BarHistory> participants)
      {
         //store the symbols' RSI value in their BarHistory instances
         foreach (BarHistory bh in participants)
         {
            int idx = GetCurrentIndex(bh); 
            TimeSeries tind = (TimeSeries)bh.Cache["IND"];

            if (live)
            {
               if (idx < bh.LastActualIndex)
                  bh.UserData = tind[idx + 1];
            }
            else
            {
               bh.UserData = tind[idx];
            }
         }

         //sort the participants by RSI value (lowest to highest)
         participants.Sort((a, b) => a.UserDataAsDouble.CompareTo(b.UserDataAsDouble));

         //keep the top symbols
         buys.Clear();
         for (int n = 0; n < PSize; n++)
         {
            if (n >= participants.Count)
               break;

            int j = participants[n].IndexOf(dt, false);
            double closePrice = live ? participants[n].Close[j + 1] : participants[n].Close[j];
            double Weight = participants[n].UserDataAsDouble;
            buys.Add(participants[n]);
            if (dt >= cutoff)
            {
               string msg = $"{dt.Date:yyyy-MM-dd} {j,-6} PreExecute {participants[n].Symbol, -6} ind: {Weight:N4}; C:{closePrice:N2}";               
               Log(msg);
            }

         }
      }

      //execute the strategy rules here, this is executed once for each bar in the backtest history
      public override void Execute(BarHistory bars, int idx)
      {         
         if (live)
         {
            // Skip final bar for MarketClose orders (per Cone rule)
            if (idx >= bars.Count - 1)
               return;

            double closePrice = bars.Close[idx + 1];
            Transaction t;
            bool inBuyList = buys.Contains(bars);
            if (!HasOpenPosition(bars, PositionType.Long))
            {
               //buy logic - buy if it's in the buys list
               if (inBuyList)
               {
                  t = PlaceTrade(bars, TransactionType.Buy, OrderType.MarketClose, 0, "RotateIn");                  
                  t.Weight = -ind[idx + 1];
                  if (idx == bars.Count - 2)
                  {
                     string msg = $"{bars.DateTimes[idx]:yyyy-MM-dd} {idx,-6} {bars.Symbol,-6} BUY RotateIn: {closePrice: N2}";
                     Log(msg);
                  }
               }
            }
            else
            {
               //sell logic, sell if it's not in the buys list
               if (!inBuyList)
               {
                  t = PlaceTrade(bars, TransactionType.Sell, OrderType.MarketClose, 0, "RotateOut");
                  t.Weight = -ind[idx + 1];
                  if (idx == bars.Count - 2)
                  {
                     string msg = $"{bars.DateTimes[idx]:yyyy-MM-dd} {idx,-6} {bars.Symbol,-6} Sell RotateOut C: {closePrice: N2}";
                     Log(msg);
                  }                  
               }
            }
         }
         else
         {
            double closePrice = bars.Close[idx];
            Transaction t;
            bool inBuyList = buys.Contains(bars);
            if (!HasOpenPosition(bars, PositionType.Long))
            {
               //buy logic - buy if it's in the buys list
               if (inBuyList)
               {
                  t = PlaceTrade(bars, TransactionType.Buy, OrderType.Market, 0, "RotateIn");
                  t.Weight = -ind[idx];
                  if (idx == bars.Count - 1)
                  {
                     string msg = $"{bars.DateTimes[idx]:yyyy-MM-dd} {idx,-6} {bars.Symbol,-6} BUY RotateIn: {closePrice: N2}";
                     Log(msg);
                  }
               }
            }
            else
            {
               //sell logic, sell if it's not in the buys list
               if (!inBuyList)
               {
                  t = PlaceTrade(bars, TransactionType.Sell, OrderType.Market, 0, "RotateOut");
                  t.Weight = -ind[idx];
                  if (idx == bars.Count - 1)
                  {
                     string msg = $"{bars.DateTimes[idx]:yyyy-MM-dd} {idx,-6} {bars.Symbol,-6} Sell RotateOut C: {closePrice: N2}";
                     Log(msg);
                  }
               }
            }
         }

      }

      void Log(string msg)
      {
         WriteToDebugLog(msg, false);
         
         DateTime now = DateTime.Now;

         string prefix = live ? "Rotation_1_" : "Rotation_0_";
         string todayFile = Path.Combine(folder, $"{prefix}{now:yyyyMMdd}.txt");

         File.AppendAllText(todayFile, $"{now:yyyy-MM-dd HH:mm:ss} {msg}\n");
      }

      //declare private variables below
      private IndicatorBase ind;
   }
}

In Testing suggested script - Signals were generated in live mode today at-close on partial bar 200.

However, PreExecute method logged RSI indicator weighs values for at-close on partial bar 200 as not changed from their values from yesterday on bar 199.
And at-close prices were logged as NAN.

I expected in live mode indicator weighs produced at-close bar 200 to differ from previous full bar 199 and see at-close prices.
Thank you.

See below PreExecute logs.

2026-10-08 14:43:23 2026-10-07 199 PreExecute GLD ind: 39.7236; C:375.88
2026-10-08 14:43:23 2026-10-07 199 PreExecute DIA ind: 41.3904; C:511.02
2026-10-08 14:43:23 2026-10-07 199 PreExecute RSP ind: 47.6428; C:210.60
2026-10-08 14:43:23 2026-10-07 199 PreExecute PFE ind: 49.8546; C:28.00
2026-10-08 14:43:23 2026-10-07 199 PreExecute XLU ind: 51.0438; C:41.15
2026-10-08 14:43:23 2026-10-07 199 PreExecute AMZN ind: 51.8689; C:259.92
2026-10-08 14:43:23 2026-10-07 199 PreExecute SOXX ind: 52.1050; C:582.82
2026-10-08 14:43:23 2026-10-07 199 PreExecute GOOGL ind: 53.3060; C:350.50
2026-10-08 14:43:23 2026-10-07 199 PreExecute TSM ind: 54.1272; C:472.20
2026-10-08 14:43:23 2026-10-07 199 PreExecute AMAT ind: 54.1400; C:520.65

2026-10-08 14:43:23 2026-10-08 200 PreExecute GLD ind: 39.7236; C:NAN
2026-10-08 14:43:23 2026-10-08 200 PreExecute DIA ind: 41.3904; C:NAN
2026-10-08 14:43:23 2026-10-08 200 PreExecute RSP ind: 47.6428; C:NAN
2026-10-08 14:43:23 2026-10-08 200 PreExecute PFE ind: 49.8546; C:NAN
2026-10-08 14:43:23 2026-10-08 200 PreExecute XLU ind: 51.0438; C:NAN
2026-10-08 14:43:23 2026-10-08 200 PreExecute AMZN ind: 51.8689; C:NAN
2026-10-08 14:43:23 2026-10-08 200 PreExecute SOXX ind: 52.1050; C:NAN
2026-10-08 14:43:23 2026-10-08 200 PreExecute GOOGL ind: 53.3060; C:NAN
2026-10-08 14:43:23 2026-10-08 200 PreExecute TSM ind: 54.1272; C:NAN
2026-10-08 14:43:23 2026-10-08 200 PreExecute AMAT ind: 54.1400; C:NAN

C: NAN indicates that it didn't get the close (or any data) from the partial bar.
In its absence, synchronization repeats the data from the previous bar.

You need to prioritize a Historical provider that will return a partial bar (checked, top of the list).
If Norgate, EODHD, or an ASCII sources, for example, are above a broker provider or Yahoo!, then you won't get the partial bar.

To get partial bars my current selections In SM testing are Yahoo! Finance,
And in Data Manager Historical providers - Yahoo! Finance on top, followed by Tingo.

Should i select Tingo to get partial bars in SM , but in Data Manager Historical providers keep Yahoo! Finance on top ?

Yahoo! should work.

However, an important piece to the data puzzle I tend to forget is that if you've assigned a "linked provider" to the DataSet you're using for the backtest, then that provider is used first.

So, if your pointing to an EODHD DataSet in the Strategy Monitor item's configuration, it won't work to retrieve a partial bar no matter how the Historical Providers are set up.

In today (and yesterday) SM testing was using Yahoo! as provider and had my dataset set as unlinked in Data Manager Historical provider from Yahoo!.
Still got at-close Price NAN and indicator weights repeated from previous bat 199. See below.

2026-10-09 14:00:04 2026-10-07 198 PreExecute GLD ind: 39.6705; C:378.62
2026-10-09 14:00:04 2026-10-07 198 PreExecute DIA ind: 41.8704; C:511.65
2026-10-09 14:00:04 2026-10-07 198 PreExecute RSP ind: 47.9394; C:211.87
2026-10-09 14:00:04 2026-10-07 198 PreExecute PFE ind: 49.3999; C:27.82
2026-10-09 14:00:04 2026-10-07 198 PreExecute AMZN ind: 50.6920; C:254.06
2026-10-09 14:00:04 2026-10-07 198 PreExecute XLU ind: 50.9871; C:41.07
2026-10-09 14:00:04 2026-10-07 198 PreExecute GOOGL ind: 53.3836; C:348.29
2026-10-09 14:00:04 2026-10-07 198 PreExecute SOXX ind: 53.7205; C:563.28
2026-10-09 14:00:04 2026-10-07 198 PreExecute NVDA ind: 54.7102; C:230.48
2026-10-09 14:00:04 2026-10-07 198 PreExecute AMAT ind: 55.6363; C:509.57

2026-10-09 14:00:04 2026-10-08 199 PreExecute GLD ind: 46.0627; C:384.87
2026-10-09 14:00:04 2026-10-08 199 PreExecute DIA ind: 49.4818; C:516.86
2026-10-09 14:00:04 2026-10-08 199 PreExecute TSM ind: 51.8328; C:451.57
2026-10-09 14:00:04 2026-10-08 199 PreExecute SOXX ind: 52.0821; C:559.70
2026-10-09 14:00:04 2026-10-08 199 PreExecute RSP ind: 52.2753; C:213.23
2026-10-09 14:00:04 2026-10-08 199 PreExecute NVDA ind: 53.7053; C:229.71
2026-10-09 14:00:04 2026-10-08 199 PreExecute PFE ind: 54.4680; C:28.16
2026-10-09 14:00:04 2026-10-08 199 PreExecute XLU ind: 54.7245; C:41.42
2026-10-09 14:00:04 2026-10-08 199 PreExecute AMAT ind: 54.7885; C:507.41
2026-10-09 14:00:04 2026-10-08 199 PreExecute GOOGL ind: 55.9972; C:351.32
2026-10-09 14:00:04 2026-10-08 199 TSM BUY RotateIn: 451.57
2026-10-09 14:00:04 2026-10-08 199 AMZN Sell RotateOut C: 261.30

2026-10-09 14:00:04 2026-10-09 200 PreExecute GLD ind: 46.0627; C:NaN
2026-10-09 14:00:04 2026-10-09 200 PreExecute DIA ind: 49.4818; C:NaN
2026-10-09 14:00:04 2026-10-09 200 PreExecute TSM ind: 51.8328; C:NaN
2026-10-09 14:00:04 2026-10-09 200 PreExecute SOXX ind: 52.0821; C:NaN
2026-10-09 14:00:04 2026-10-09 200 PreExecute RSP ind: 52.2753; C:NaN
2026-10-09 14:00:04 2026-10-09 200 PreExecute NVDA ind: 53.7053; C:NaN
2026-10-09 14:00:04 2026-10-09 200 PreExecute PFE ind: 54.4680; C:NaN
2026-10-09 14:00:04 2026-10-09 200 PreExecute XLU ind: 54.7245; C:NaN
2026-10-09 14:00:04 2026-10-09 200 PreExecute AMAT ind: 54.7885; C:NaN
2026-10-09 14:00:04 2026-10-09 200 PreExecute GOOGL ind: 55.9972; C:NaN

All the timestamps are 14:00:04. Are you not waiting for the At-Close Processing run? (At-Close doesn't work with "Run Now".)

The At-Close run can be configured, at most, 720 seconds (12 minutes) before the market close. Your settings should be configured as below.

I set up at-close exacltly per your suggestions - 720sec and checked wait for all updates box. Still same issue with bar 200 NaN prices and weights repeated from 199 bar. See below.

2026-10-12 14:48:04 2026-10-09 199 PreExecute GLD ind: 43.8185; C:382.12
2026-10-12 14:48:04 2026-10-09 199 PreExecute SOXX ind: 45.8787; C:544.94
2026-10-12 14:48:04 2026-10-09 199 PreExecute TSM ind: 48.3011; C:445.34
2026-10-12 14:48:04 2026-10-09 199 PreExecute NVDA ind: 50.0065; C:226.80
2026-10-12 14:48:04 2026-10-09 199 PreExecute DIA ind: 50.6095; C:517.65
2026-10-12 14:48:04 2026-10-09 199 PreExecute AMAT ind: 51.0706; C:497.80
2026-10-12 14:48:04 2026-10-09 199 PreExecute RSP ind: 51.6745; C:213.02
2026-10-12 14:48:04 2026-10-09 199 PreExecute AMD ind: 52.9647; C:593.62
2026-10-12 14:48:04 2026-10-09 199 PreExecute AMZN ind: 55.6168; C:259.66
2026-10-12 14:48:04 2026-10-09 199 PreExecute GEV ind: 56.6450; C:999.12
2026-10-12 14:48:04 2026-10-09 199 AMD BUY RotateIn: 593.62
2026-10-12 14:48:04 2026-10-09 199 AMZN BUY RotateIn: 259.66
2026-10-12 14:48:04 2026-10-09 199 GEV BUY RotateIn: 999.12
2026-10-12 14:48:04 2026-10-09 199 XLU Sell RotateOut C: 41.62
2026-10-12 14:48:04 2026-10-09 199 PFE Sell RotateOut C: 28.43
2026-10-12 14:48:04 2026-10-09 199 AAPL Sell RotateOut C: 340.42
2026-10-12 14:48:04 2026-10-12 200 PreExecute GLD ind: 43.8185; C:NaN
2026-10-12 14:48:04 2026-10-12 200 PreExecute SOXX ind: 45.8787; C:NaN
2026-10-12 14:48:04 2026-10-12 200 PreExecute TSM ind: 48.3011; C:NaN
2026-10-12 14:48:04 2026-10-12 200 PreExecute NVDA ind: 50.0065; C:NaN
2026-10-12 14:48:04 2026-10-12 200 PreExecute DIA ind: 50.6095; C:NaN
2026-10-12 14:48:04 2026-10-12 200 PreExecute AMAT ind: 51.0706; C:NaN
2026-10-12 14:48:04 2026-10-12 200 PreExecute RSP ind: 51.6745; C:NaN
2026-10-12 14:48:04 2026-10-12 200 PreExecute AMD ind: 52.9647; C:NaN
2026-10-12 14:48:04 2026-10-12 200 PreExecute AMZN ind: 55.6168; C:NaN
2026-10-12 14:48:04 2026-10-12 200 PreExecute GEV ind: 56.6450; C:NaN

And SM log
10/12/2026 10:36:38: Status = LoadingData
10/12/2026 10:36:38: Start Polling Thread
10/12/2026 10:36:38: Populating Data
10/12/2026 10:36:38: Calling GetHistories Pass 1
10/12/2026 10:36:38: GetHistories returned with 21 symbols
10/12/2026 10:36:38: Calling GetHistories Pass 2
10/12/2026 10:36:39: GetHistories returned with 21 symbols
10/12/2026 10:36:39: GLD 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: DIA 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: MRNA 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: GEV 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: QQQ 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: RSP 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: SOXX 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: SPY 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: PFE 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: XLE 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: XLU 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: AMD 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: AMAT 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: CVX 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: NVDA 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: META 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: MSFT 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: AMZN 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: GOOGL 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: AAPL 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: TSM 200 bars to 10/9/2026 | Yahoo! Finance
10/12/2026 10:36:39: NextRun set to 10/12/2026 14:48
10/12/2026 10:36:39: Status = Idle
10/12/2026 14:48:01: Status = Processing
10/12/2026 14:48:01: Collecting Partial Bars
10/12/2026 14:48:02: Partial Bar added for MRNA: 10/12/2026 00:00 O:224.23500061035156 H:227.44500732421875 L:210.91000366210938C:214.3800048828125
10/12/2026 14:48:02: Partial Bar added for SOXX: 10/12/2026 00:00 O:552.666015625 H:552.75 L:543.3400268554688C:544.9400024414062
10/12/2026 14:48:02: Partial Bar added for GEV: 10/12/2026 00:00 O:999.989990234375 H:1004 L:991C:999.125
10/12/2026 14:48:02: Partial Bar added for PFE: 10/12/2026 00:00 O:28.420000076293945 H:28.4950008392334 L:28.280000686645508C:28.434999465942383
10/12/2026 14:48:02: Partial Bar added for RSP: 10/12/2026 00:00 O:213.30999755859375 H:213.42999267578125 L:212.61000061035156C:213.02499389648438
10/12/2026 14:48:02: Partial Bar added for XLE: 10/12/2026 00:00 O:65.8499984741211 H:66.41999816894531 L:65.66500091552734C:65.9749984741211
10/12/2026 14:48:02: Partial Bar added for QQQ: 10/12/2026 00:00 O:749.6400146484375 H:749.7899780273438 L:744.844970703125C:745.8400268554688
10/12/2026 14:48:02: Partial Bar added for SPY: 10/12/2026 00:00 O:778.780029296875 H:779.39697265625 L:777.0499877929688C:777.8300170898438
10/12/2026 14:48:02: Partial Bar added for XLU: 10/12/2026 00:00 O:41.459999084472656 H:41.630001068115234 L:41.20000076293945C:41.6150016784668
10/12/2026 14:48:02: Partial Bar added for DIA: 10/12/2026 00:00 O:516.4199829101562 H:518.5800170898438 L:516.5075073242188C:517.6500244140625
10/12/2026 14:48:02: Partial Bar added for GLD: 10/12/2026 00:00 O:382.6050109863281 H:382.739990234375 L:381.1600036621094C:382.1199951171875
10/12/2026 14:48:03: Partial Bar added for AMD: 10/12/2026 00:00 O:599.8599853515625 H:601.77001953125 L:586.5399780273438C:593.6199951171875
10/12/2026 14:48:03: Partial Bar added for AMAT: 10/12/2026 00:00 O:501.0199890136719 H:501.4599914550781 L:491.9700012207031C:497.79998779296875
10/12/2026 14:48:03: Partial Bar added for CVX: 10/12/2026 00:00 O:214.5399932861328 H:216.6699981689453 L:213.75010681152344C:215.22000122070312
10/12/2026 14:48:03: Partial Bar added for AAPL: 10/12/2026 00:00 O:338.1600036621094 H:342.6300048828125 L:337.6000061035156C:340.4200134277344
10/12/2026 14:48:03: Partial Bar added for META: 10/12/2026 00:00 O:727.969970703125 H:752.239990234375 L:727.780029296875C:742.780029296875
10/12/2026 14:48:03: Partial Bar added for GOOGL: 10/12/2026 00:00 O:351.94000244140625 H:356.5 L:350.5C:353.19000244140625
10/12/2026 14:48:03: Partial Bar added for NVDA: 10/12/2026 00:00 O:228.72999572753906 H:228.86000061035156 L:224.9199981689453C:226.8000030517578
10/12/2026 14:48:03: Partial Bar added for AMZN: 10/12/2026 00:00 O:262.5450134277344 H:263.70001220703125 L:259.2799987792969C:259.6600036621094
10/12/2026 14:48:03: Partial Bar added for TSM: 10/12/2026 00:00 O:453.54998779296875 H:454.3999938964844 L:445C:445.3399963378906
10/12/2026 14:48:04: Partial Bar added for MSFT: 10/12/2026 00:00 O:538.0700073242188 H:542.739990234375 L:535.7012939453125C:540.375
10/12/2026 14:48:04: Ran Strategy on MRNA,SOXX,GEV,PFE,RSP,XLE,QQQ,SPY,XLU,DIA,GLD,AMD,AMAT,CVX,AAPL,META,GOOGL,NVDA,AMZN,TSM,MSFT: 6 Signals, Run Time=311ms
10/12/2026 14:48:04: NextRun set to 10/12/2026 18:00
10/12/2026 14:48:04: Status = Completed
10/12/2026 14:48:04: Processed all Symbols

It looks like it ran fine. There must be a bug in what's sent to the log, which seems to be incomplete - data records are missing for several of the symbols.

The discrepancy is that you're copying data for the last date in the log for PreExecute for "Live mode", but you need to be inspecting the data from previous date; in this case 2026-10-09.

For the At-Close run to work, we're adding the partial bar (for today) and peeking at it when processing the previous day to generate the MarketClose order, which is then immediately executed as a Market order.

The run on the partial bar's date still occurs in PreExecute, but is ignored in Execute because of this:

CODE:
            // Skip final bar for MarketClose orders (per Cone rule)
            if (idx >= bars.Count - 1)
               return;

So in Preexecute script below to properly log at-close Price I replaced
double closePrice = live ? participants[n].Close[j + 1] : participants[n].Close[j];
with double closePrice = participants[n].Close[j];

But what about properly logging indicator weights logged as
double Weight = participants[n].UserDataAsDouble;

But though in live mode weight as participants[n].UserDataAsDouble looks 1 bar (partial bar) forward, it still expected to repeat from previous bar ?

Here is the script -

public override void PreExecute(DateTime dt, List<BarHistory> participants)
{
//store the symbols' RSI value in their BarHistory instances
foreach (BarHistory bh in participants)
{
int idx = GetCurrentIndex(bh);
TimeSeries tind = (TimeSeries)bh.Cache["IND"];

if (live)
{
if (idx < bh.LastActualIndex)
bh.UserData = tind[idx + 1];
}
else
{
bh.UserData = tind[idx];
}
}

//sort the participants by RSI value (lowest to highest)
participants.Sort((a, b) => a.UserDataAsDouble.CompareTo(b.UserDataAsDouble));

//keep the top symbols
buys.Clear();
for (int n = 0; n < PSize; n++)
{
if (n >= participants.Count)
break;

int j = participants[n].IndexOf(dt, false);
//replaced double closePrice = live ? participants[n].Close[j + 1] : participants[n].Close[j];
double closePrice = participants[n].Close[j];

double Weight = participants[n].UserDataAsDouble;
buys.Add(participants[n]);
if (dt >= cutoff)
{
string msg = $"{dt.Date:yyyy-MM-dd} {j,-6} PreExecute {participants[n].Symbol, -6} ind: {Weight:N4}; C:{closePrice:N2}";
Log(msg);
}

}
}

After implementing suggested Preexecute fix in Live mode - the at close prices are logged with no issues.

Still wonder why in live mode current (partial) bar 200 Indicator weights are repeated from previous bar, another words should weights be updated on partial bar 200 to reflect at close prices according to Preexecute logic ?

if (live)
{
if (idx < bh.LastActualIndex)
bh.UserData = tind[idx + 1];
}
else
{
bh.UserData = tind[idx];
}


2026-10-13 14:49:44 2026-10-12 199 PreExecute AMAT ind: 40.1659; C:497.53
2026-10-13 14:49:44 2026-10-12 199 PreExecute GLD ind: 43.6042; C:382.15
2026-10-13 14:49:44 2026-10-12 199 PreExecute SOXX ind: 44.8202; C:544.85
2026-10-13 14:49:44 2026-10-12 199 PreExecute TSM ind: 47.9006; C:444.35
2026-10-13 14:49:44 2026-10-12 199 PreExecute DIA ind: 49.0854; C:517.91
2026-10-13 14:49:44 2026-10-12 199 PreExecute NVDA ind: 51.5509; C:226.32
2026-10-13 14:49:44 2026-10-12 199 PreExecute RSP ind: 53.0279; C:213.19
2026-10-13 14:49:44 2026-10-12 199 PreExecute QQQ ind: 54.9730; C:746.04
2026-10-13 14:49:44 2026-10-12 199 PreExecute AMD ind: 55.2936; C:594.24
2026-10-13 14:49:44 2026-10-12 199 PreExecute AMZN ind: 55.5722; C:259.53
2026-10-13 14:49:44 2026-10-12 199 QQQ BUY RotateIn: 743.38
2026-10-13 14:49:44 2026-10-12 199 GEV Sell RotateOut C: 1,004.28
2026-10-13 14:49:44 2026-10-13 200 PreExecute AMAT ind: 40.1659; C:462.18
2026-10-13 14:49:44 2026-10-13 200 PreExecute GLD ind: 43.6042; C:381.86
2026-10-13 14:49:44 2026-10-13 200 PreExecute SOXX ind: 44.8202; C:542.22
2026-10-13 14:49:44 2026-10-13 200 PreExecute TSM ind: 47.9006; C:444.53
2026-10-13 14:49:44 2026-10-13 200 PreExecute DIA ind: 49.0854; C:516.57
2026-10-13 14:49:44 2026-10-13 200 PreExecute NVDA ind: 51.5509; C:228.03
2026-10-13 14:49:44 2026-10-13 200 PreExecute RSP ind: 53.0279; C:213.43
2026-10-13 14:49:44 2026-10-13 200 PreExecute QQQ ind: 54.9730; C:743.38
2026-10-13 14:49:44 2026-10-13 200 PreExecute AMD ind: 55.2936; C:602.39
2026-10-13 14:49:44 2026-10-13 200 PreExecute AMZN ind: 55.5722; C:259.64