diff --git a/Include/MyIncludes/Chandelier_Exit_Calculator.mqh b/Include/MyIncludes/Chandelier_Exit_Calculator.mqh
new file mode 100644
index 0000000..717f0c8
--- /dev/null
+++ b/Include/MyIncludes/Chandelier_Exit_Calculator.mqh
@@ -0,0 +1,278 @@
+//+------------------------------------------------------------------+
+//|                                   Chandelier_Exit_Calculator.mqh |
+//|                                          Copyright 2026, xxxxxxxx|
+//+------------------------------------------------------------------+
+#property copyright "Copyright 2026, xxxxxxxx"
+#property version   "1.00" // Performance optimized Chandelier Exit engine wrapping ATR v3.00
+#property description "Stateful calculator implementing Charles LeBeau Chandelier Exit (ATR Trailing Stop)."
+
+#ifndef CHANDELIER_EXIT_CALCULATOR_MQH
+#define CHANDELIER_EXIT_CALCULATOR_MQH
+
+#include <MyIncludes\ATR_Calculator.mqh>
+#include <MyIncludes\HeikinAshi_Tools.mqh>
+
+//+==================================================================+
+//|             CLASS: CChandelierExitCalculator                     |
+//+==================================================================+
+class CChandelierExitCalculator
+  {
+private:
+   int               m_period;
+   double            m_multiplier;
+   bool              m_is_ha;
+
+   CATRCalculator    *m_atr_calc;
+   double            m_atr_buffer[];
+
+   // Persistent Price Caches
+   double            m_price_high[];
+   double            m_price_low[];
+   double            m_price_close[];
+
+   // Persistent State Registers for Trailing Stop ratchets
+   double            m_long_stop[];
+   double            m_short_stop[];
+   double            m_trend[];
+
+   double            Highest(const double &array[], int period, int current_pos);
+   double            Lowest(const double &array[], int period, int current_pos);
+   bool              PrepareSourceData(int rates_total, int start_index, const double &open[], const double &high[], const double &low[], const double &close[]);
+
+public:
+                     CChandelierExitCalculator(void);
+                    ~CChandelierExitCalculator(void);
+
+   bool              Init(int period, double multiplier, bool is_ha);
+   void              Calculate(int rates_total, int prev_calculated,
+                               const double &open[], const double &high[], const double &low[], const double &close[],
+                               double &stop_line[], double &color_buffer[]);
+  };
+
+//+------------------------------------------------------------------+
+//| Constructor                                                      |
+//+------------------------------------------------------------------+
+CChandelierExitCalculator::CChandelierExitCalculator(void)
+   : m_period(22),
+     m_multiplier(3.0),
+     m_is_ha(false),
+     m_atr_calc(NULL)
+  {
+  }
+
+//+------------------------------------------------------------------+
+//| Destructor                                                       |
+//+------------------------------------------------------------------+
+CChandelierExitCalculator::~CChandelierExitCalculator(void)
+  {
+   if(CheckPointer(m_atr_calc) != POINTER_INVALID)
+      delete m_atr_calc;
+  }
+
+//+------------------------------------------------------------------+
+//| Init                                                             |
+//+------------------------------------------------------------------+
+bool CChandelierExitCalculator::Init(int period, double multiplier, bool is_ha)
+  {
+   m_period     = (period < 1) ? 1 : period;
+   m_multiplier = (multiplier <= 0.0) ? 3.0 : multiplier;
+   m_is_ha      = is_ha;
+
+   if(CheckPointer(m_atr_calc) != POINTER_INVALID)
+     {
+      delete m_atr_calc;
+      m_atr_calc = NULL;
+     }
+
+// Dynamic polymorphic instantiation of the underlying refactored ATR engine
+   if(m_is_ha)
+      m_atr_calc = new CATRCalculator_HA();
+   else
+      m_atr_calc = new CATRCalculator();
+
+   if(CheckPointer(m_atr_calc) == POINTER_INVALID || !m_atr_calc.Init(m_period, ATR_POINTS))
+      return false;
+
+   return true;
+  }
+
+//+------------------------------------------------------------------+
+//| Calculate (Stateful O(1) Trailing Stop logic)                    |
+//+------------------------------------------------------------------+
+void CChandelierExitCalculator::Calculate(int rates_total, int prev_calculated,
+      const double &open[], const double &high[], const double &low[], const double &close[],
+      double &stop_line[], double &color_buffer[])
+  {
+   if(rates_total < m_period + 5)
+      return;
+
+//--- Resize state buffers and enforce chronological safety
+   if(ArraySize(m_atr_buffer) != rates_total)
+     {
+      ArrayResize(m_atr_buffer,  rates_total);
+      ArrayResize(m_price_high,  rates_total);
+      ArrayResize(m_price_low,   rates_total);
+      ArrayResize(m_price_close, rates_total);
+      ArrayResize(m_long_stop,   rates_total);
+      ArrayResize(m_short_stop,  rates_total);
+      ArrayResize(m_trend,       rates_total);
+
+      ArraySetAsSeries(m_atr_buffer,  false);
+      ArraySetAsSeries(m_price_high,  false);
+      ArraySetAsSeries(m_price_low,   false);
+      ArraySetAsSeries(m_price_close, false);
+      ArraySetAsSeries(m_long_stop,   false);
+      ArraySetAsSeries(m_short_stop,  false);
+      ArraySetAsSeries(m_trend,       false);
+     }
+
+//--- 1. Prepare Source Price Data (Standard or HA)
+   int start_index = (prev_calculated > 0) ? prev_calculated - 1 : 0;
+   if(!PrepareSourceData(rates_total, start_index, open, high, low, close))
+      return;
+
+//--- 2. Calculate volatility baseline using refactored ATR v3.00
+   m_atr_calc.Calculate(rates_total, prev_calculated, open, high, low, close, m_atr_buffer);
+
+   int loop_start = MathMax(m_period, start_index);
+
+//--- 3. Warm-up Initialization
+   if(loop_start == m_period)
+     {
+      for(int i = 0; i < m_period; i++)
+        {
+         m_long_stop[i]  = 0.0;
+         m_short_stop[i] = 0.0;
+         m_trend[i]      = 1.0;
+         stop_line[i]    = m_price_close[i];
+         color_buffer[i] = 0.0;
+        }
+     }
+
+//--- 4. Calculate Raw Stop Bands
+   for(int i = loop_start; i < rates_total; i++)
+     {
+      m_long_stop[i]  = Highest(m_price_high, m_period, i) - m_multiplier * m_atr_buffer[i];
+      m_short_stop[i] = Lowest(m_price_low, m_period, i) + m_multiplier * m_atr_buffer[i];
+     }
+
+//--- 5. Trailing Stop Ratchet & Trend Logic
+   for(int i = loop_start; i < rates_total; i++)
+     {
+      // Trend flip conditions
+      if(m_price_close[i] > m_short_stop[i - 1])
+         m_trend[i] = 1.0; // Bullish
+      else
+         if(m_price_close[i] < m_long_stop[i - 1])
+            m_trend[i] = -1.0; // Bearish
+         else
+            m_trend[i] = m_trend[i - 1];
+
+      // Ratchet assignment (stop can only move in favor of the trend or stay flat)
+      if(m_trend[i] == 1.0)
+        {
+         if(m_long_stop[i] > stop_line[i - 1] || m_trend[i - 1] == -1.0)
+            stop_line[i] = m_long_stop[i];
+         else
+            stop_line[i] = stop_line[i - 1];
+
+         color_buffer[i] = 0.0; // Index 0: Bullish (clrDodgerBlue)
+        }
+      else // Bearish
+        {
+         if(m_short_stop[i] < stop_line[i - 1] || stop_line[i - 1] == 0.0 || m_trend[i - 1] == 1.0)
+            stop_line[i] = m_short_stop[i];
+         else
+            stop_line[i] = stop_line[i - 1];
+
+         color_buffer[i] = 1.0; // Index 1: Bearish (clrTomato)
+        }
+
+      // Connect lines on trend transitions (MT5 drawing trick for color lines)
+      if(m_trend[i] != m_trend[i - 1])
+        {
+         if(m_trend[i] == 1.0)
+            stop_line[i - 1] = m_long_stop[i];
+         else
+            stop_line[i - 1] = m_short_stop[i];
+        }
+     }
+  }
+
+//+------------------------------------------------------------------+
+//| Find Highest Value over Period                                   |
+//+------------------------------------------------------------------+
+double CChandelierExitCalculator::Highest(const double &array[], int period, int current_pos)
+  {
+   double res = array[current_pos];
+   for(int i = 1; i < period; i++)
+     {
+      if(current_pos - i < 0)
+         break;
+      if(res < array[current_pos - i])
+         res = array[current_pos - i];
+     }
+   return res;
+  }
+
+//+------------------------------------------------------------------+
+//| Find Lowest Value over Period                                    |
+//+------------------------------------------------------------------+
+double CChandelierExitCalculator::Lowest(const double &array[], int period, int current_pos)
+  {
+   double res = array[current_pos];
+   for(int i = 1; i < period; i++)
+     {
+      if(current_pos - i < 0)
+         break;
+      if(res > array[current_pos - i])
+         res = array[current_pos - i];
+     }
+   return res;
+  }
+
+//+------------------------------------------------------------------+
+//| Prepare Source Data Series (Standard or Heikin Ashi)             |
+//+------------------------------------------------------------------+
+bool CChandelierExitCalculator::PrepareSourceData(int rates_total, int start_index, const double &open[], const double &high[], const double &low[], const double &close[])
+  {
+   if(m_is_ha)
+     {
+      static CHeikinAshi_Calculator ha_calc;
+      static double ha_open[], ha_high[], ha_low[], ha_close[];
+      if(ArraySize(ha_open) != rates_total)
+        {
+         ArrayResize(ha_open,  rates_total);
+         ArrayResize(ha_high,  rates_total);
+         ArrayResize(ha_low,   rates_total);
+         ArrayResize(ha_close, rates_total);
+
+         ArraySetAsSeries(ha_open,  false);
+         ArraySetAsSeries(ha_high,  false);
+         ArraySetAsSeries(ha_low,   false);
+         ArraySetAsSeries(ha_close, false);
+        }
+
+      ha_calc.Calculate(rates_total, start_index, open, high, low, close, ha_open, ha_high, ha_low, ha_close);
+
+      for(int i = start_index; i < rates_total; i++)
+        {
+         m_price_high[i]  = ha_high[i];
+         m_price_low[i]   = ha_low[i];
+         m_price_close[i] = ha_close[i];
+        }
+     }
+   else
+     {
+      for(int i = start_index; i < rates_total; i++)
+        {
+         m_price_high[i]  = high[i];
+         m_price_low[i]   = low[i];
+         m_price_close[i] = close[i];
+        }
+     }
+   return true;
+  }
+
+#endif // CHANDELIER_EXIT_CALCULATOR_MQH
+//+------------------------------------------------------------------+