Desenvolvendo uma estratégia de pullback: Fundamentos

Introdução

Você já viu o movimento clássico: o preço dispara, muitos perdem a entrada no rompimento e, logo depois, surge o recuo. Visualmente, o pullback parece simples — mas como transformar essa leitura em regras objetivas, reproduzíveis e testáveis no MetaTrader 5?

Neste artigo, será construído um núcleo inicial de pullback para day trade, pensado principalmente para mercados futuros como WIN e WDO, onde faz sentido encerrar posições no mesmo pregão. Ainda assim, a lógica pode ser adaptada para outros mercados, como Forex, permitindo configurar ou desativar as janelas operacionais conforme o ativo.

A proposta é trabalhar com candles fechados e modelo OHLC, usando poucos graus de liberdade: dois timeframes e duas EMAs. O objetivo é verificar se a sequência regime → retração → retomada apresenta comportamento estatisticamente útil antes da inclusão de stops, alvos, filtros ou gestão avançada.

Por isso, o primeiro EA não utiliza stop loss, take profit, parciais, breakeven ou trailing. Ele testa apenas a lógica base: regime por EMA em timeframe superior, retração por EMA em timeframe inferior, gatilho por cruzamento de retomada e saída por inversão do regime ou fim do dia.

Figure 1 - Pullback

Entre o rompimento e a reversão: onde o pullback se encaixa

Muitas estratégias tentam entrar no rompimento. Outras tentam capturar reversões. O pullback fica em uma região intermediária.

Ele não busca comprar o fundo absoluto nem vender o topo exato. Também não exige entrar no rompimento inicial, quando o preço muitas vezes já está esticado. A ideia é esperar o mercado revelar uma direção, recuar de forma controlada e oferecer uma nova chance de entrada com melhor relação entre risco e retorno.

Em termos práticos, o pullback tenta responder a uma pergunta simples: "O mercado já mostrou direção. Existe agora uma correção saudável que permita entrar melhor nesse movimento?"

Essa é a diferença central. O pullback não tenta prever o movimento do zero. Ele espera o mercado mostrar força primeiro.

Figure 2 - Strategies

Os quatro pilares de uma estratégia de pullback

Uma estratégia de pullback pode ser organizada em quatro partes:

• Regime: define a direção principal do mercado.
• Retração: identifica a correção contra esse regime.
• Gatilho: confirma a tentativa de retomada.
• Gestão: controla risco, saída e proteção do trade.

Quando esses elementos trabalham juntos, a estratégia fica mais clara. O regime evita operar contra o contexto. A retração evita entradas esticadas. O gatilho reduz entradas antecipadas. A gestão impede que uma boa ideia vire uma operação ruim.

Figure 3- The 4 states of pullback

Como implementar a lógica de pullback

A implementação de uma estratégia de pullback deve começar pela separação clara dos módulos. O primeiro passo é definir como o sistema identifica o regime. Isso pode ser feito por médias móveis, inclinação, estrutura de máximas e mínimas, ADX, volatilidade ou outro critério objetivo.

Depois, é necessário definir o que será considerado uma retração válida. O preço precisa voltar até uma região específica? Pode tocar uma média? Deve se aproximar de uma zona de valor? A retração deve ter limite máximo? Quantos candles ela pode durar antes de perder validade?

Em seguida, vem o gatilho. O sistema precisa de uma regra que confirme a tentativa de retomada. Pode ser o rompimento da máxima do candle anterior em compras, o rompimento da mínima em vendas, um fechamento direcional, uma rejeição ou outro sinal mensurável.

Por fim, entra a gestão. Essa etapa define onde a operação será invalidada, como o lucro será protegido e quando a posição será encerrada. A gestão é especialmente importante porque nem todo pullback funcionará. O objetivo não é acertar todos os trades, mas criar uma estrutura em que os ganhos compensem as perdas ao longo do tempo.

Objetivo inicial do EA

Antes de avançar para filtros mais sofisticados, a proposta será iniciar com um EA de pullback extremamente simples. A intenção é observar se a lógica básica de regime e recuo já apresenta algum comportamento aproveitável no day trade, mesmo sem stop, take profit, parcial, trailing stop ou confirmação avançada de gatilho.

Por isso, este primeiro EA foi estruturado com poucos graus de liberdade. A princípio, os principais parâmetros analisados são  o timeframe e o período da EMA de regime e retração.

A lógica do estudo é simples: se um modelo com poucos parâmetros já mostrar algum comportamento estável, existe uma base interessante para aprofundamento. Caso contrário, adicionar filtros, stops, alvos e gestão antes de validar a ideia principal poderia apenas mascarar um problema estrutural da entrada.

Os principais objetivos desta primeira implementação são:

• Construir um EA de pullback simples para day trade.

• Operar inicialmente sem stop loss e sem take profit definido.

• Não utilizar parcial, break-even ou trailing stop nesta fase.

• Trabalhar apenas com a lógica básica de regime, recuo e retomada.

• Usar o cruzamento da média como referência principal do pullback.

• Evitar filtros excessivos no início do desenvolvimento.

• Reduzir os graus de liberdade para facilitar a leitura dos resultados.

• Verificar se existe algum cenário com comportamento estável.

• Identificar se a lógica de entrada possui valor antes de adicionar gestão.

• Utilizar apenas candles fechados de modo a convergir ou aproximar resultados OHLC com cada tick.

Com essa estrutura, será possível analisar primeiro o comportamento bruto do pullback. Caso a lógica simples mostre algum padrão promissor, novas camadas poderão ser adicionadas gradualmente, como filtros de regime, critérios mais fortes de retração, gatilhos de confirmação, stops, alvos e gestão completa da posição.

O código completo estará disponível em anexo. A seguir, serão mostrados apenas os trechos que explicam a formação da lógica principal.

1. Graus de liberdade

A primeira decisão do código foi permitir que o regime e a retração usassem timeframes diferentes. Isso é importante porque o regime pode se beneficiar de um timeframe maior, mais limpo e menos sensível ao ruído, enquanto a retração pode ser observada em um timeframe menor, com mais detalhes sobre o retorno do preço.

Para facilitar a otimização, os timeframes foram organizados em um enum. Assim, o otimizador trabalha com índices simples, e o EA converte esses índices para timeframes reais do MetaTrader 5.

enum ENUM_CORE_TIMEFRAME_INDEX
  {
   CORE_TF_M1  = 0,
   CORE_TF_M2  = 1,
   CORE_TF_M3  = 2,
   CORE_TF_M5  = 3,
   CORE_TF_M10 = 4,
   CORE_TF_M15 = 5
  };

Os parâmetros otimizáveis principais são:

//--- Timeframe used to define the main market regime.
//--- It can range from M1 to M15.
input ENUM_CORE_TIMEFRAME_INDEX regimeTimeframeIndex = CORE_TF_M5;

//--- Timeframe used to observe the retracement.
//--- It can also range from M1 to M15.
input ENUM_CORE_TIMEFRAME_INDEX retracementTimeframeIndex = CORE_TF_M1; 

//--- EMA period used for the regime.
input int regimeEMAPeriod = 70;

//--- EMA period used for the retracement.
input int retracementEMAPeriod = 20;

Essa escolha reduz bastante a complexidade do estudo. Em vez de começar com muitos filtros, o EA inicialmente testa apenas quatro dimensões principais: timeframe do regime, timeframe da retração, período da EMA do regime e período da EMA da retração.

Essa simplicidade é proposital. O objetivo é descobrir se há alguma combinação de contexto e recuo que apresente estabilidade antes de adicionar novas camadas.

2. Implementando o Regime

Nesta versão, o regime foi definido com apenas uma EMA. A compra é permitida quando o último candle fechado do timeframe de regime fecha acima dessa média. A venda é permitida quando o fechamento ocorre abaixo dela.

Poderíamos iniciar com ADX, duas EMAs, inclinação, separação entre médias, volatilidade, estrutura de máximas e mínimas ou filtros de lateralidade. Porém, isso aumentaria os graus de liberdade logo no começo. Como a proposta é estudar o comportamento mais básico possível, uma única EMA permite uma leitura objetiva e direta do contexto.

A EMA funciona aqui como uma linha dinâmica de separação. Se o preço fechado está acima dela, o mercado é interpretado como comprador. Se está abaixo, o mercado é interpretado como vendedor.

//+------------------------------------------------------------------+
//| Checks whether the buy regime is active.                         |
//| The EA uses only the last fully closed candle on the regime TF.  |
//| A buy regime exists when the candle closes above the regime EMA. |
//+------------------------------------------------------------------+
bool BuyRegime()
  {
//--- Shift 1 is the last fully closed candle.
//--- Shift 0 is still forming and is not used for signals.
   if(ArraySize(g_regimeRates) <= 1 || ArraySize(g_regimeEMA) <= 1)
      return false;

//--- Buy regime:
//--- closed price is above the regime EMA.
   return (g_regimeRates[1].close > g_regimeEMA[1]);
  }

//+------------------------------------------------------------------+
//| Checks whether the sell regime is active.                        |
//| The EA uses only the last fully closed candle on the regime TF.  |
//| A sell regime exists when the candle closes below the regime EMA.|
//+------------------------------------------------------------------+
bool SellRegime()
  {
//--- Shift 1 is the last fully closed candle.
//--- Shift 0 is ignored to avoid using an unfinished signal.
   if(ArraySize(g_regimeRates) <= 1 || ArraySize(g_regimeEMA) <= 1)
      return false;

//--- Sell regime:
//--- closed price is below the regime EMA.
   return (g_regimeRates[1].close < g_regimeEMA[1]);
  }

O uso de timeframes maiores e períodos maiores no regime tende a deixar essa leitura mais estável. Um regime em M5, M10 ou M15 com uma EMA mais longa reage menos ao ruído imediato do preço. Isso pode reduzir trocas frequentes de direção e produzir um contexto mais limpo para procurar retrações.

Por outro lado, um regime muito lento pode atrasar a leitura e entregar entradas depois que boa parte do movimento já aconteceu. Por isso, essa primeira bateria deixa o timeframe e o período da EMA de regime como pontos centrais de análise.

3. Atualização do regime e limpeza dos estados

Após definir as funções de compra e venda, o EA atualiza o estado do regime. Quando um novo regime aparece, ele limpa retrações antigas. Isso evita que um recuo detectado em um contexto anterior seja usado após uma mudança de direção.

Essa parte é importante porque transforma o regime em uma memória operacional. O EA não apenas calcula se o preço está acima ou abaixo da EMA; ele guarda qual lado está ativo e apaga estados incompatíveis quando o contexto muda.

//+------------------------------------------------------------------+
//| Updates the active regime state using closed candles only.       |
//| When the regime changes, old retracement states are cleared      |
//| so the EA does not reuse signals from a previous context.        |
//+------------------------------------------------------------------+
void UpdateRegime()
  {
//--- Check the current regime using the last closed regime candle.
   bool buy = BuyRegime();
   bool sell = SellRegime();

   if(buy)
     {
      //--- If a new buy regime has just appeared,
      //--- clear old retracement states.
      if(!g_buyRegimeActive)
         ClearRetracements();

      g_buyRegimeActive = true;
      g_sellRegimeActive = false;
      return;
     }

   if(sell)
     {
      //--- If a new sell regime has just appeared,
      //--- clear old retracement states as well.
      if(!g_sellRegimeActive)
         ClearRetracements();

      g_buyRegimeActive = false;
      g_sellRegimeActive = true;
      return;
     }

//--- If there is no clear regime, no side remains active.
   g_buyRegimeActive = false;
   g_sellRegimeActive = false;
   ClearRetracements();
  }
//+------------------------------------------------------------------+

4. Retração: uma segunda EMA em timeframe selecionável

Após o regime estar ativo, o EA procura a retração. A retração também usa uma única EMA, mas em um timeframe próprio. Isso permite, por exemplo, usar um regime mais limpo em M5, M10 ou M15 e uma retração mais sensível em M1, M2 ou M3.

Para compras, a retração ocorre quando o último candle fechado da retração fecha abaixo ou igual à EMA de retração. Para vendas, ocorre quando o fechamento fica acima ou igual à EMA.

Essa definição é simples e objetiva. O EA não mede ainda profundidade do recuo, rejeição, tamanho de candle, rompimento, Fibonacci ou suporte e resistência. O foco é observar se o preço, ao retornar para a EMA de retração dentro de um regime ativo, cria alguma condição aproveitável.

//+------------------------------------------------------------------+
//| Detects a buy retracement candle.                                |
//| In a buy regime, retracement is identified when the closed price |
//| is below or equal to the retracement EMA.                        |
//+------------------------------------------------------------------+
bool BuyRetracementCandle()
  {
//--- Check if there is enough retracement data.
   if(ArraySize(g_retracementRates) <= 1 || ArraySize(g_retracementEMA) <= 1)
      return false;

//--- Buy retracement:
//--- closed price is below or equal to the retracement EMA.
   return (g_retracementRates[1].close <= g_retracementEMA[1]);
  }

//+------------------------------------------------------------------+
//| Detects a sell retracement candle.                               |
//| In a sell regime, retracement is identified when the closed      |
//| price is above or equal to the retracement EMA.                  |
//+------------------------------------------------------------------+
bool SellRetracementCandle()
  {
//--- Check if there is enough retracement data.
   if(ArraySize(g_retracementRates) <= 1 || ArraySize(g_retracementEMA) <= 1)
      return false;

//--- Sell retracement:
//--- closed price is above or equal to the retracement EMA.
   return (g_retracementRates[1].close >= g_retracementEMA[1]);
  }

5. Retomada: cruzamento de volta pela EMA de retração

Embora o EA seja simples, ele não entra apenas no primeiro fechamento contra a EMA. Depois que a retração é armada, a entrada ocorre quando o preço cruza de volta a EMA de retração a favor do regime.

Para compra, o candle anterior estava abaixo ou igual à EMA e o candle atual fechado ficou acima dela. Para venda, o candle anterior estava acima ou igual à EMA e o candle atual fechado ficou abaixo.

Esse gatilho ainda é básico. Ele não usa rompimento de máxima ou mínima, força de candle ou padrão de preço. A função apenas confirma que, depois da retração, o preço voltou para o lado favorável da EMA de retração.

//+------------------------------------------------------------------+
//| Detects a bullish cross back through the retracement EMA.        |
//| The previous closed candle must be below or equal to the EMA,    |
//| while the latest closed candle must close above it.              |
//+------------------------------------------------------------------+
bool CrossedUpRetracementEMA()
  {
//--- At least two closed candles are required:
//--- shift 2 = previous closed candle
//--- shift 1 = latest closed candle.
   if(ArraySize(g_retracementRates) <= 2 || ArraySize(g_retracementEMA) <= 2)
      return false;

//--- The previous candle closed below or equal to the EMA.
   bool previousClosedBelowOrEqual =
      (g_retracementRates[2].close <= g_retracementEMA[2]);

//--- The latest candle crossed back and closed above the EMA.
   bool currentClosedAbove =
      (g_retracementRates[1].close > g_retracementEMA[1]);

//--- Simple buy resumption trigger.
   return (previousClosedBelowOrEqual && currentClosedAbove);
  }

//+------------------------------------------------------------------+
//| Detects a bearish cross back through the retracement EMA.        |
//| The previous closed candle must be above or equal to the EMA,    |
//| while the latest closed candle must close below it.              |
//+------------------------------------------------------------------+
bool CrossedDownRetracementEMA()
  {
//--- At least two closed candles are required:
//--- shift 2 = previous closed candle
//--- shift 1 = latest closed candle.
   if(ArraySize(g_retracementRates) <= 2 || ArraySize(g_retracementEMA) <= 2)
      return false;

//--- The previous candle closed above or equal to the EMA.
   bool previousClosedAboveOrEqual =
      (g_retracementRates[2].close >= g_retracementEMA[2]);

//--- The latest candle crossed back and closed below the EMA.
   bool currentClosedBelow =
      (g_retracementRates[1].close < g_retracementEMA[1]);

//--- Simple sell resumption trigger.
   return (previousClosedAboveOrEqual && currentClosedBelow);
  }

6. Ativação de gatilho

A função que une retração e gatilho é UpdateRetracementAndTrigger(). Ela verifica se existe regime ativo, arma a retração e depois aguarda o cruzamento de volta pela EMA de retração.

//+------------------------------------------------------------------+
//| Updates retracement state and checks the EMA cross trigger.      |
//| The function uses only closed candles from the retracement TF.   |
//| No SL, TP, partial close, trailing, or advanced filters are used.|
//+------------------------------------------------------------------+
void UpdateRetracementAndTrigger()
  {
//--- Do not open a new position if there is already exposure,
//--- if hedging is blocked, or if the EA is outside the entry window.
   if(!CanOpenNewPosition())
      return;

   if(g_buyRegimeActive)
     {
      //--- In a buy regime, remove any sell retracement state.
      ClearSellRetracement();

      //--- Arm the buy retracement when price closes
      //--- below or equal to the retracement EMA.
      if(!g_buyRetracementActive && BuyRetracementCandle())
        {
         g_buyRetracementActive = true;
         g_buyRetracementStartTime = g_retracementRates[1].time;
        }

      //--- After the retracement is armed, wait for price
      //--- to cross back above the retracement EMA.
      if(g_buyRetracementActive && CrossedUpRetracementEMA())
         OpenTrade(true);

      return;
     }

   if(g_sellRegimeActive)
     {
      //--- In a sell regime, remove any buy retracement state.
      ClearBuyRetracement();

      //--- Arm the sell retracement when price closes
      //--- above or equal to the retracement EMA.
      if(!g_sellRetracementActive && SellRetracementCandle())
        {
         g_sellRetracementActive = true;
         g_sellRetracementStartTime = g_retracementRates[1].time;
        }

      //--- After the retracement is armed, wait for price
      //--- to cross back below the retracement EMA.
      if(g_sellRetracementActive && CrossedDownRetracementEMA())
         OpenTrade(false);

      return;
     }

//--- If no regime is active, remove all retracement states.
   ClearRetracements();
  }

7. Entrada sem stop e sem take profit

Quando o regime está ativo, a retração foi armada e o cruzamento de retomada ocorre, o EA abre uma posição a mercado. A ordem é enviada sem stop loss e sem take profit.

//+------------------------------------------------------------------+
//| Sends a market order without stop loss and take profit.          |
//| This is intentional in the diagnostic core version.              |
//| Exits are handled only by regime reversal or end-of-day close.   |
//+------------------------------------------------------------------+
bool SendMarketOrder(const ENUM_ORDER_TYPE orderType,
                     const double volume,
                     const ulong magic)
  {
//--- Normalize the requested volume according to symbol rules.
   double normalizedVolume = NormalizeVolume(volume);

   if(normalizedVolume <= 0.0)
      return false;

   MqlTradeRequest request;
   MqlTradeResult result;

   ZeroMemory(request);
   ZeroMemory(result);

   request.action = TRADE_ACTION_DEAL;
   request.symbol = _Symbol;
   request.magic = magic;
   request.volume = normalizedVolume;
   request.deviation = g_deviation;
   request.type = orderType;
   request.type_filling = ORDER_FILLING_FOK;
   request.price = (orderType == ORDER_TYPE_BUY ? g_ask : g_bid);

//--- No SL and no TP by design.
//--- This keeps the first test focused on the entry logic.
   request.sl = 0.0;
   request.tp = 0.0;

   if(!OrderSend(request, result))
      return false;

   return (result.retcode == TRADE_RETCODE_DONE ||
           result.retcode == TRADE_RETCODE_DONE_PARTIAL ||
           result.retcode == TRADE_RETCODE_PLACED);
  }

Isso não deve ser interpretado como uma recomendação operacional para conta real. A ausência de SL e TP é uma escolha de pesquisa. O objetivo é observar o comportamento natural da entrada e deixar que a saída dependa apenas da mudança de regime ou do fim do pregão.

Com isso, a gestão não interfere no teste inicial. Se a entrada tiver algum valor estrutural, ela deve aparecer mesmo antes de uma gestão mais sofisticada.

8. Fechamento por invalidação do regime

A saída principal ocorre quando o regime se inverte. Uma compra é encerrada quando o regime passa a ser vendedor. Uma venda é encerrada quando o regime passa a ser comprador.

//+------------------------------------------------------------------+
//| Manages exits by regime invalidation.                            |
//| Buy positions are closed when the regime turns bearish.          |
//| Sell positions are closed when the regime turns bullish.         |
//+------------------------------------------------------------------+
void ManageExitByRegime()
  {
//--- If there is an open buy position and the regime turns bearish,
//--- close the buy position.
   if(HasBuyPosition() && SellRegime())
     {
      CloseBuyPosition("regime_reversed_to_sell");
      ClearRetracements();
     }

//--- If there is an open sell position and the regime turns bullish,
//--- close the sell position.
   if(HasSellPosition() && BuyRegime())
     {
      CloseSellPosition("regime_reversed_to_buy");
      ClearRetracements();
     }
  }

Esse modelo faz com que a própria EMA de regime funcione como referência de invalidação. Enquanto o regime não se inverte, a posição permanece aberta. Quando o regime muda, o trade é encerrado.

Isso reforça o caráter diagnóstico do EA. A saída não depende de alvo fixo, stop técnico ou gestão de lucro. Ela mede a capacidade da combinação regime + retração + retomada de permanecer em um movimento até que o contexto principal seja invalidado.

9. Fechamento forçado no fim do dia

Como o objetivo é day trade, o EA também possui fechamento forçado no fim do pregão. Se o horário limite for atingido, todas as posições abertas pelo EA são encerradas.

//+------------------------------------------------------------------+
//| Checks whether the EA must force close all positions.            |
//| This protects the strategy from carrying trades overnight.       |
//+------------------------------------------------------------------+
bool MustForceCloseEndOfDay(const datetime when)
  {
//--- End-of-day protection.
//--- If the day trade window is enabled and the forced close time
//--- has been reached, all EA positions must be closed.
   return (useDaytradeWindow &&
           forceCloseAtEndOfDay &&
           MinutesOfDay(when) >= forcedCloseMinute);
  }

No OnTick(), essa proteção é executada antes da busca por novas entradas:

//+------------------------------------------------------------------+
//| Main EA execution loop.                                          |
//| Updates market data, protects the end of the day, manages regime |
//| exits, and evaluates entries only on closed retracement candles. |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Read the latest tick.
   if(!SymbolInfoTick(_Symbol, g_tick))
      return;

//--- Update candles and EMA buffers.
   if(!UpdateMarketData())
      return;

//--- End-of-day protection:
//--- if the limit time has been reached,
//--- close all positions and clear retracement states.
   if(MustForceCloseEndOfDay(g_tick.time))
     {
      ForceCloseAllPositions();
      ClearRetracements();
      return;
     }

//--- Update regime and manage exits.
//--- These functions use closed-bar values.
   UpdateRegime();
   ManageExitByRegime();

//--- Entry logic is evaluated only when a new retracement
//--- timeframe candle starts.
//--- This guarantees that the signal candle is closed.
   if(!NewRetracementBar())
      return;

   UpdateRegime();
   ManageExitByRegime();

   if(!EntryTimeAllowed(g_tick.time))
      return;

   UpdateRetracementAndTrigger();
  }

Dessa forma, o EA respeita a proposta de day trade. Nenhuma operação deve permanecer aberta após o horário definido para fechamento.

Fluxo completo da lógica

O fluxo final desta primeira versão pode ser resumido assim:

Núcleo inicial do EA:

1. Escolher o timeframe do regime.
2. Escolher o período da EMA de regime.
3. Verificar se o fechamento está acima ou abaixo da EMA.
4. Escolher o timeframe da retração.
5. Escolher o período da EMA de retração.
6. Aguardar fechamento contra a EMA de retração.
7. Aguardar cruzamento de volta pela EMA de retração.
8. Abrir entrada sem SL e sem TP.
9. Fechar apenas por inversão do regime ou fim do dia.

Resultados

Os testes iniciais foram realizados no contrato contínuo do Mini Índice, entre 2021 á 2024, utilizando o modelo OHLC para acelerar a simulação, já que a estratégia trabalha apenas com candles fechados. A bateria avaliou regimes em M5, M10 e M15, retração/gatilho em M1, M2 e M3, além de EMAs de regime e retração entre 10 e 80 períodos.

Mesmo sem stop loss, take profit, trailing ou filtros adicionais, a estratégia apresentou um comportamento relevante. Os melhores resultados se concentraram em uma estrutura com regime mais lento e retração/gatilho mais rápidos, especialmente com regime em M15, retração em M1, EMA de regime 75 e EMA de retração 40.

Resultados principais da simulação:

Figure 4 - Backtest

O resultado ainda não deve ser interpretado como uma estratégia final, pois o fator de lucro e o payoff permanecem limitados. No entanto, o lucro líquido positivo e a quantidade relevante de operações indicam que a lógica básica possui valor como investigação inicial. A principal leitura é que o filtro de regime mais lento ajuda a reduzir operações em lateralidade, enquanto o gatilho rápido em M1 permite buscar entradas mais precisas após o recuo.

Conclusão

O artigo formalizou o pullback como um processo modular e entregou um artefato reproduzível: um diagnóstico EA para MT5 cujo núcleo usa apenas 2 timeframes e 2 períodos de EMA. Regras centrais inovadoras e prontas para reprodução:

• Regime: uma EMA no timeframe escolhido (TF superior) - compra quando vela fechada acima, venda quando abaixo.
• Retração: segunda EMA em timeframe menor - retração quando o fechamento toca/ultrapassa essa EMA contra o regime.
• Gatilho: entrada quando o preço cruza de volta a EMA de retração a favor do regime.
• Saídas: fechamento por inversão do regime ou por fechamento proposto no fim do dia.
• Ambiente de teste: velas internas, modelo OHLC no MT5; otimização limitada a (regime TF, retração TF, regime EMA, retração EMA).

Resultados preliminares mostram lucro bruto e número relevante de operações em algumas modificações (por exemplo: regime lento em TF maior + retração rápida em M1), demonstrando que a lógica básica merece investigação adicional - mas não específica sinal para uso em conta real, dado que o EA não usa SL/TP e a robustez ainda precisa ser validada.

Próximos passos

1. Definir detalhes de sucesso exatos (expectativa, fator de lucro, percentual de pior drawdown) e critérios de acessibilidade.
2. Incluir gestão mínima (SL/TP sensível ao spread/volatilidade) e testar impacto.
3. Adicione filtros graduais (Análise de estrutura, tamanho da retração) e avalie incrementalmente.
4. Automatizar relatórios de sensibilidade e conservar a concepção do núcleo como linha de base.

Em suma: entregamos uma projeção operacional e uma implementação de diagnóstico para avaliar o valor estrutural do pullback. A recomendação é progresso por etapas documentadas - cada nova camada só deve permanecer para comprovar melhoria consistente nas considerações previamente definidas.

№	Nome	Tipo	Descrição
1	OneEMA_Core.mq5	Expert Advisor	EA de EMA Simples Pullback