Your strategy, written as code you can rely on.

//--- Risk-based lot size, normalised to every broker constraint.
//--- The three lines most EAs skip are exactly why they die on a
//--- live account and never in the tester.
double LotForRisk(const double riskPercent, const double stopPoints)
{
   if(stopPoints <= 0.0) return(0.0);

   const double equity    = AccountInfoDouble(ACCOUNT_EQUITY);
   const double tickValue = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_VALUE);
   const double tickSize  = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);
   if(tickValue <= 0.0 || tickSize <= 0.0) return(0.0);

   const double lossPerLot = (stopPoints * _Point / tickSize) * tickValue;
   if(lossPerLot <= 0.0) return(0.0);

   double lots = (equity * riskPercent / 100.0) / lossPerLot;

   //--- step / min / max. Without these you get "invalid volume"
   //--- at 02:00 and the robot silently stops trading.
   const double step = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);
   const double lo   = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   const double hi   = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);

   lots = MathFloor(lots / step) * step;
   lots = MathMax(lo, MathMin(hi, lots));

   return(NormalizeDouble(lots, (int)MathRound(-MathLog10(step))));
}

//@version=6
indicator("HTF trend filter", overlay = true)

// A higher-timeframe value is only safe to act on once that bar has
// closed. The [1] offset reads the last closed HTF bar; lookahead_on
// makes history and real time switch to it at the same moment. Drop
// the [1] and history reads the future; drop lookahead_on and history
// runs one HTF bar behind what the live chart showed.
htf    = input.timeframe("240", "Higher timeframe")
length = input.int(50, "EMA length", minval = 2)

htfEma = request.security(syminfo.tickerid, htf,
                          ta.ema(close, length)[1],
                          lookahead = barmerge.lookahead_on)

trendUp = not na(htfEma) and close > htfEma

plot(htfEma, "HTF EMA", linewidth = 2,
     color = trendUp ? color.new(#FFAA2B, 0) : color.new(#E8604C, 0))

alertcondition(ta.crossover(close, htfEma), "Cross up",
               "Close crossed above the higher-timeframe EMA")

/**
 * Order dispatch that is safe to retry.
 *
 * A network timeout does not tell you whether the broker filled the
 * order. Retrying blindly is how one intended position quietly
 * becomes three. The client-side key makes the broker reject the
 * duplicate instead of accepting it.
 */
export async function dispatch(order: Order, deps: Deps): Promise<Ack> {
  const key = idempotencyKey(order);       // stable across retries

  const known = await deps.store.find(key);
  if (known) return known;                 // already acknowledged

  for (let attempt = 0; attempt < MAX_ATTEMPTS; attempt++) {
    try {
      const ack = await deps.broker.send({ ...order, clientOrderId: key });
      await deps.store.record(key, ack);
      return ack;
    } catch (err) {
      if (!isTransient(err)) throw err;
      await sleep(backoff(attempt));       // 250ms, 500ms, 1s, 2s
    }
  }
  throw new DispatchTimeout(key, MAX_ATTEMPTS);
}