backtest-kit 3.2.0 → 3.3.0

package/build/index.mjs

@@ -2880,6 +2880,27 @@ class ExchangeConnectionService {
     }
 }
 
+/**
+ * Returns the effective entry price for price calculations.
+ *
+ * When the _entry array exists and has at least one element, returns
+ * the simple arithmetic mean of all entry prices (DCA average).
+ * Otherwise returns the original signal.priceOpen.
+ *
+ * This mirrors the _trailingPriceStopLoss pattern: original price is preserved
+ * in signal.priceOpen (for identity/tracking), while calculations use the
+ * effective averaged price returned by this function.
+ *
+ * @param signal - Signal row (ISignalRow or IScheduledSignalRow)
+ * @returns Effective entry price for distance and PNL calculations
+ */
+const getEffectivePriceOpen = (signal) => {
+    if (signal._entry && signal._entry.length > 0) {
+        return signal._entry.reduce((sum, e) => sum + e.price, 0) / signal._entry.length;
+    }
+    return signal.priceOpen;
+};
+
 /**
  * Calculates profit/loss for a closed signal with slippage and fees.
  *
@@ -2930,7 +2951,7 @@ class ExchangeConnectionService {
  * ```
  */
 const toProfitLossDto = (signal, priceClose) => {
-    const priceOpen = signal.priceOpen;
+    const priceOpen = getEffectivePriceOpen(signal);
     // Calculate weighted PNL with partial closes
     if (signal._partial && signal._partial.length > 0) {
         let totalWeightedPnl = 0;
@@ -3184,6 +3205,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 percentToClose: commit.percentToClose,
                 currentPrice: commit.currentPrice,
                 timestamp,
+                totalEntries: publicSignal.totalEntries,
                 position: publicSignal.position,
                 priceOpen: publicSignal.priceOpen,
                 signalId: publicSignal.id,
@@ -3191,6 +3213,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 priceStopLoss: publicSignal.priceStopLoss,
                 originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
                 originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
             });
@@ -3207,6 +3230,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 percentToClose: commit.percentToClose,
                 currentPrice: commit.currentPrice,
                 timestamp,
+                totalEntries: publicSignal.totalEntries,
                 position: publicSignal.position,
                 priceOpen: publicSignal.priceOpen,
                 signalId: publicSignal.id,
@@ -3214,6 +3238,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 priceStopLoss: publicSignal.priceStopLoss,
                 originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
                 originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
             });
@@ -3229,6 +3254,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 backtest: commit.backtest,
                 currentPrice: commit.currentPrice,
                 timestamp,
+                totalEntries: publicSignal.totalEntries,
                 signalId: publicSignal.id,
                 position: publicSignal.position,
                 priceOpen: publicSignal.priceOpen,
@@ -3236,6 +3262,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 priceStopLoss: publicSignal.priceStopLoss,
                 originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
                 originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
             });
@@ -3252,6 +3279,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 percentShift: commit.percentShift,
                 currentPrice: commit.currentPrice,
                 timestamp,
+                totalEntries: publicSignal.totalEntries,
                 signalId: publicSignal.id,
                 position: publicSignal.position,
                 priceOpen: publicSignal.priceOpen,
@@ -3259,6 +3287,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 priceStopLoss: publicSignal.priceStopLoss,
                 originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
                 originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
             });
@@ -3275,6 +3304,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 percentShift: commit.percentShift,
                 currentPrice: commit.currentPrice,
                 timestamp,
+                totalEntries: publicSignal.totalEntries,
                 signalId: publicSignal.id,
                 position: publicSignal.position,
                 priceOpen: publicSignal.priceOpen,
@@ -3282,6 +3312,33 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
                 priceStopLoss: publicSignal.priceStopLoss,
                 originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
                 originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                originalPriceOpen: publicSignal.originalPriceOpen,
+                scheduledAt: publicSignal.scheduledAt,
+                pendingAt: publicSignal.pendingAt,
+            });
+            continue;
+        }
+        if (commit.action === "average-buy") {
+            const effectivePriceOpen = getEffectivePriceOpen(self._pendingSignal);
+            await CALL_COMMIT_FN(self, {
+                action: "average-buy",
+                symbol: commit.symbol,
+                strategyName: self.params.strategyName,
+                exchangeName: self.params.exchangeName,
+                frameName: self.params.frameName,
+                backtest: commit.backtest,
+                currentPrice: commit.currentPrice,
+                effectivePriceOpen,
+                timestamp,
+                totalEntries: publicSignal.totalEntries,
+                signalId: publicSignal.id,
+                position: publicSignal.position,
+                priceOpen: publicSignal.originalPriceOpen,
+                priceTakeProfit: publicSignal.priceTakeProfit,
+                priceStopLoss: publicSignal.priceStopLoss,
+                originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
+                originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
             });
@@ -3342,13 +3399,20 @@ const TO_PUBLIC_SIGNAL = (signal) => {
     const partialExecuted = ("_partial" in signal && Array.isArray(signal._partial))
         ? signal._partial.reduce((sum, partial) => sum + partial.percent, 0)
         : 0;
+    const totalEntries = ("_entry" in signal && Array.isArray(signal._entry))
+        ? signal._entry.length
+        : 1;
+    const effectivePriceOpen = "_entry" in signal ? getEffectivePriceOpen(signal) : signal.priceOpen;
     return {
         ...structuredClone(signal),
+        priceOpen: effectivePriceOpen,
         priceStopLoss: hasTrailingSL ? signal._trailingPriceStopLoss : signal.priceStopLoss,
         priceTakeProfit: hasTrailingTP ? signal._trailingPriceTakeProfit : signal.priceTakeProfit,
+        originalPriceOpen: signal.priceOpen,
         originalPriceStopLoss: signal.priceStopLoss,
         originalPriceTakeProfit: signal.priceTakeProfit,
         partialExecuted,
+        totalEntries,
     };
 };
 const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
@@ -3678,6 +3742,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
                 scheduledAt: currentTime,
                 pendingAt: currentTime, // Для immediate signal оба времени одинаковые
                 _isScheduled: false,
+                _entry: [{ price: signal.priceOpen }],
             };
             // Валидируем сигнал перед возвратом
             VALIDATE_SIGNAL_FN(signalRow, currentPrice, false);
@@ -3699,6 +3764,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
             scheduledAt: currentTime,
             pendingAt: SCHEDULED_SIGNAL_PENDING_MOCK, // Временно, обновится при активации
             _isScheduled: true,
+            _entry: [{ price: signal.priceOpen }],
         };
         // Валидируем сигнал перед возвратом
         VALIDATE_SIGNAL_FN(scheduledSignalRow, currentPrice, true);
@@ -3716,6 +3782,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         scheduledAt: currentTime,
         pendingAt: currentTime, // Для immediate signal оба времени одинаковые
         _isScheduled: false,
+        _entry: [{ price: currentPrice }],
     };
     // Валидируем сигнал перед возвратом
     VALIDATE_SIGNAL_FN(signalRow, currentPrice, false);
@@ -3862,9 +3929,10 @@ const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice) => {
     return true;
 };
 const TRAILING_STOP_LOSS_FN = (self, signal, percentShift) => {
+    const effectivePriceOpen = getEffectivePriceOpen(signal);
     // CRITICAL: Always calculate from ORIGINAL SL, not from current trailing SL
     // This prevents error accumulation on repeated calls
-    const originalSlDistancePercent = Math.abs((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen * 100);
+    const originalSlDistancePercent = Math.abs((effectivePriceOpen - signal.priceStopLoss) / effectivePriceOpen * 100);
     // Calculate new stop-loss distance percentage by adding shift to ORIGINAL distance
     // Negative percentShift: reduces distance % (tightens stop, moves SL toward entry or beyond)
     // Positive percentShift: increases distance % (loosens stop, moves SL away from entry)
@@ -3876,13 +3944,13 @@ const TRAILING_STOP_LOSS_FN = (self, signal, percentShift) => {
         // LONG: SL is below entry (or above entry if in profit zone)
         // Formula: entry * (1 - newDistance%)
         // Example: entry=100, originalSL=90 (10%), shift=-5% → newDistance=5% → 100 * 0.95 = 95 (tighter)
-        newStopLoss = signal.priceOpen * (1 - newSlDistancePercent / 100);
+        newStopLoss = effectivePriceOpen * (1 - newSlDistancePercent / 100);
     }
     else {
         // SHORT: SL is above entry (or below entry if in profit zone)
         // Formula: entry * (1 + newDistance%)
         // Example: entry=100, originalSL=110 (10%), shift=-5% → newDistance=5% → 100 * 1.05 = 105 (tighter)
-        newStopLoss = signal.priceOpen * (1 + newSlDistancePercent / 100);
+        newStopLoss = effectivePriceOpen * (1 + newSlDistancePercent / 100);
     }
     const currentTrailingSL = signal._trailingPriceStopLoss;
     const isFirstCall = currentTrailingSL === undefined;
@@ -3945,9 +4013,10 @@ const TRAILING_STOP_LOSS_FN = (self, signal, percentShift) => {
     }
 };
 const TRAILING_TAKE_PROFIT_FN = (self, signal, percentShift) => {
+    const effectivePriceOpen = getEffectivePriceOpen(signal);
     // CRITICAL: Always calculate from ORIGINAL TP, not from current trailing TP
     // This prevents error accumulation on repeated calls
-    const originalTpDistancePercent = Math.abs((signal.priceTakeProfit - signal.priceOpen) / signal.priceOpen * 100);
+    const originalTpDistancePercent = Math.abs((signal.priceTakeProfit - effectivePriceOpen) / effectivePriceOpen * 100);
     // Calculate new take-profit distance percentage by adding shift to ORIGINAL distance
     // Negative percentShift: reduces distance % (brings TP closer to entry)
     // Positive percentShift: increases distance % (moves TP further from entry)
@@ -3958,13 +4027,13 @@ const TRAILING_TAKE_PROFIT_FN = (self, signal, percentShift) => {
         // LONG: TP is above entry
         // Formula: entry * (1 + newDistance%)
         // Example: entry=100, originalTP=110 (10%), shift=-3% → newDistance=7% → 100 * 1.07 = 107 (closer)
-        newTakeProfit = signal.priceOpen * (1 + newTpDistancePercent / 100);
+        newTakeProfit = effectivePriceOpen * (1 + newTpDistancePercent / 100);
     }
     else {
         // SHORT: TP is below entry
         // Formula: entry * (1 - newDistance%)
         // Example: entry=100, originalTP=90 (10%), shift=-3% → newDistance=7% → 100 * 0.93 = 93 (closer)
-        newTakeProfit = signal.priceOpen * (1 - newTpDistancePercent / 100);
+        newTakeProfit = effectivePriceOpen * (1 - newTpDistancePercent / 100);
     }
     const currentTrailingTP = signal._trailingPriceTakeProfit;
     const isFirstCall = currentTrailingTP === undefined;
@@ -4025,6 +4094,7 @@ const TRAILING_TAKE_PROFIT_FN = (self, signal, percentShift) => {
     }
 };
 const BREAKEVEN_FN = (self, signal, currentPrice) => {
+    const effectivePriceOpen = getEffectivePriceOpen(signal);
     // Calculate breakeven threshold based on slippage and fees
     // Need to cover: entry slippage + entry fee + exit slippage + exit fee
     // Total: (slippage + fee) * 2 transactions
@@ -4032,10 +4102,10 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
     // Check if trailing stop is already set
     if (signal._trailingPriceStopLoss !== undefined) {
         const trailingStopLoss = signal._trailingPriceStopLoss;
-        const breakevenPrice = signal.priceOpen;
+        const breakevenPrice = effectivePriceOpen;
         if (signal.position === "long") {
             // LONG: trailing SL is positive if it's above entry (in profit zone)
-            const isPositiveTrailing = trailingStopLoss > signal.priceOpen;
+            const isPositiveTrailing = trailingStopLoss > effectivePriceOpen;
             if (isPositiveTrailing) {
                 // Trailing stop is already protecting profit - consider breakeven achieved
                 self.params.logger.debug("BREAKEVEN_FN: positive trailing stop already set, returning true", {
@@ -4051,7 +4121,7 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
             else {
                 // Trailing stop is negative (below entry)
                 // Check if we can upgrade it to breakeven
-                const thresholdPrice = signal.priceOpen * (1 + breakevenThresholdPercent / 100);
+                const thresholdPrice = effectivePriceOpen * (1 + breakevenThresholdPercent / 100);
                 const isThresholdReached = currentPrice >= thresholdPrice;
                 if (isThresholdReached && breakevenPrice > trailingStopLoss) {
                     // Check for price intrusion before setting new SL
@@ -4100,7 +4170,7 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
         }
         else {
             // SHORT: trailing SL is positive if it's below entry (in profit zone)
-            const isPositiveTrailing = trailingStopLoss < signal.priceOpen;
+            const isPositiveTrailing = trailingStopLoss < effectivePriceOpen;
             if (isPositiveTrailing) {
                 // Trailing stop is already protecting profit - consider breakeven achieved
                 self.params.logger.debug("BREAKEVEN_FN: positive trailing stop already set, returning true", {
@@ -4116,7 +4186,7 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
             else {
                 // Trailing stop is negative (above entry)
                 // Check if we can upgrade it to breakeven
-                const thresholdPrice = signal.priceOpen * (1 - breakevenThresholdPercent / 100);
+                const thresholdPrice = effectivePriceOpen * (1 - breakevenThresholdPercent / 100);
                 const isThresholdReached = currentPrice <= thresholdPrice;
                 if (isThresholdReached && breakevenPrice < trailingStopLoss) {
                     // Check for price intrusion before setting new SL
@@ -4166,21 +4236,21 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
     }
     // No trailing stop set - proceed with normal breakeven logic
     const currentStopLoss = signal.priceStopLoss;
-    const breakevenPrice = signal.priceOpen;
+    const breakevenPrice = effectivePriceOpen;
     // Calculate threshold price
     let thresholdPrice;
     let isThresholdReached;
     let canMoveToBreakeven;
     if (signal.position === "long") {
         // LONG: threshold reached when price goes UP by breakevenThresholdPercent from entry
-        thresholdPrice = signal.priceOpen * (1 + breakevenThresholdPercent / 100);
+        thresholdPrice = effectivePriceOpen * (1 + breakevenThresholdPercent / 100);
         isThresholdReached = currentPrice >= thresholdPrice;
         // Can move to breakeven only if threshold reached and SL is below entry
         canMoveToBreakeven = isThresholdReached && currentStopLoss < breakevenPrice;
     }
     else {
         // SHORT: threshold reached when price goes DOWN by breakevenThresholdPercent from entry
-        thresholdPrice = signal.priceOpen * (1 - breakevenThresholdPercent / 100);
+        thresholdPrice = effectivePriceOpen * (1 - breakevenThresholdPercent / 100);
         isThresholdReached = currentPrice <= thresholdPrice;
         // Can move to breakeven only if threshold reached and SL is above entry
         canMoveToBreakeven = isThresholdReached && currentStopLoss > breakevenPrice;
@@ -4240,8 +4310,51 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
         thresholdPrice,
         breakevenThresholdPercent,
         profitDistancePercent: signal.position === "long"
-            ? ((currentPrice - signal.priceOpen) / signal.priceOpen * 100)
-            : ((signal.priceOpen - currentPrice) / signal.priceOpen * 100),
+            ? ((currentPrice - effectivePriceOpen) / effectivePriceOpen * 100)
+            : ((effectivePriceOpen - currentPrice) / effectivePriceOpen * 100),
+    });
+    return true;
+};
+const AVERAGE_BUY_FN = (self, signal, currentPrice) => {
+    // Ensure _entry is initialized (handles signals loaded from disk without _entry)
+    if (!signal._entry || signal._entry.length === 0) {
+        signal._entry = [{ price: signal.priceOpen }];
+    }
+    const lastEntry = signal._entry[signal._entry.length - 1];
+    if (signal.position === "long") {
+        // LONG: averaging down = currentPrice must be strictly lower than last entry
+        if (currentPrice >= lastEntry.price) {
+            self.params.logger.debug("AVERAGE_BUY_FN: rejected — currentPrice >= last entry (LONG)", {
+                signalId: signal.id,
+                position: signal.position,
+                currentPrice,
+                lastEntryPrice: lastEntry.price,
+                reason: "must average down for LONG",
+            });
+            return false;
+        }
+    }
+    else {
+        // SHORT: averaging down = currentPrice must be strictly higher than last entry
+        if (currentPrice <= lastEntry.price) {
+            self.params.logger.debug("AVERAGE_BUY_FN: rejected — currentPrice <= last entry (SHORT)", {
+                signalId: signal.id,
+                position: signal.position,
+                currentPrice,
+                lastEntryPrice: lastEntry.price,
+                reason: "must average down for SHORT",
+            });
+            return false;
+        }
+    }
+    signal._entry.push({ price: currentPrice });
+    self.params.logger.info("AVERAGE_BUY_FN executed", {
+        signalId: signal.id,
+        position: signal.position,
+        originalPriceOpen: signal.priceOpen,
+        newEntryPrice: currentPrice,
+        newEffectivePrice: getEffectivePriceOpen(signal),
+        totalEntries: signal._entry.length,
     });
     return true;
 };
@@ -4970,9 +5083,10 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
     await CALL_ACTIVE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentTime, self.params.execution.context.backtest);
     // Calculate percentage of path to TP/SL for partial fill/loss callbacks
     {
+        const effectivePriceOpen = getEffectivePriceOpen(signal);
         if (signal.position === "long") {
             // For long: calculate progress towards TP or SL
-            const currentDistance = currentPrice - signal.priceOpen;
+            const currentDistance = currentPrice - effectivePriceOpen;
             if (currentDistance > 0) {
                 // Check if breakeven should be triggered
                 await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
@@ -4980,7 +5094,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
             if (currentDistance > 0) {
                 // Moving towards TP (use trailing TP if set)
                 const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
-                const tpDistance = effectiveTakeProfit - signal.priceOpen;
+                const tpDistance = effectiveTakeProfit - effectivePriceOpen;
                 const progressPercent = (currentDistance / tpDistance) * 100;
                 percentTp = Math.min(progressPercent, 100);
                 await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentTp, currentTime, self.params.execution.context.backtest);
@@ -4988,7 +5102,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
             else if (currentDistance < 0) {
                 // Moving towards SL (use trailing SL if set)
                 const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
-                const slDistance = signal.priceOpen - effectiveStopLoss;
+                const slDistance = effectivePriceOpen - effectiveStopLoss;
                 const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                 percentSl = Math.min(progressPercent, 100);
                 await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentSl, currentTime, self.params.execution.context.backtest);
@@ -4996,7 +5110,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
         }
         else if (signal.position === "short") {
             // For short: calculate progress towards TP or SL
-            const currentDistance = signal.priceOpen - currentPrice;
+            const currentDistance = effectivePriceOpen - currentPrice;
             if (currentDistance > 0) {
                 // Check if breakeven should be triggered
                 await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
@@ -5004,7 +5118,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
             if (currentDistance > 0) {
                 // Moving towards TP (use trailing TP if set)
                 const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
-                const tpDistance = signal.priceOpen - effectiveTakeProfit;
+                const tpDistance = effectivePriceOpen - effectiveTakeProfit;
                 const progressPercent = (currentDistance / tpDistance) * 100;
                 percentTp = Math.min(progressPercent, 100);
                 await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentTp, currentTime, self.params.execution.context.backtest);
@@ -5012,7 +5126,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
             if (currentDistance < 0) {
                 // Moving towards SL (use trailing SL if set)
                 const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
-                const slDistance = effectiveStopLoss - signal.priceOpen;
+                const slDistance = effectiveStopLoss - effectivePriceOpen;
                 const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                 percentSl = Math.min(progressPercent, 100);
                 await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentSl, currentTime, self.params.execution.context.backtest);
@@ -5232,8 +5346,10 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                 priceStopLoss: publicSignalForCommit.priceStopLoss,
                 originalPriceTakeProfit: publicSignalForCommit.originalPriceTakeProfit,
                 originalPriceStopLoss: publicSignalForCommit.originalPriceStopLoss,
+                originalPriceOpen: publicSignalForCommit.originalPriceOpen,
                 scheduledAt: publicSignalForCommit.scheduledAt,
                 pendingAt: publicSignalForCommit.pendingAt,
+                totalEntries: publicSignalForCommit.totalEntries,
             });
             await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, pendingSignal, pendingSignal.priceOpen, candle.timestamp, self.params.execution.context.backtest);
             await CALL_BACKTEST_SCHEDULE_OPEN_FN(self, self.params.execution.context.symbol, pendingSignal, candle.timestamp, self.params.execution.context.backtest);
@@ -5380,9 +5496,10 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         // Call onPartialProfit/onPartialLoss callbacks during backtest candle processing
         // Calculate percentage of path to TP/SL
         {
+            const effectivePriceOpen = getEffectivePriceOpen(signal);
             if (signal.position === "long") {
                 // For long: calculate progress towards TP or SL
-                const currentDistance = averagePrice - signal.priceOpen;
+                const currentDistance = averagePrice - effectivePriceOpen;
                 if (currentDistance > 0) {
                     // Check if breakeven should be triggered
                     await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, averagePrice, currentCandleTimestamp, self.params.execution.context.backtest);
@@ -5390,21 +5507,21 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                 if (currentDistance > 0) {
                     // Moving towards TP (use trailing TP if set)
                     const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
-                    const tpDistance = effectiveTakeProfit - signal.priceOpen;
+                    const tpDistance = effectiveTakeProfit - effectivePriceOpen;
                     const progressPercent = (currentDistance / tpDistance) * 100;
                     await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
                 else if (currentDistance < 0) {
                     // Moving towards SL (use trailing SL if set)
                     const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
-                    const slDistance = signal.priceOpen - effectiveStopLoss;
+                    const slDistance = effectivePriceOpen - effectiveStopLoss;
                     const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                     await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
             }
             else if (signal.position === "short") {
                 // For short: calculate progress towards TP or SL
-                const currentDistance = signal.priceOpen - averagePrice;
+                const currentDistance = effectivePriceOpen - averagePrice;
                 if (currentDistance > 0) {
                     // Check if breakeven should be triggered
                     await CALL_BREAKEVEN_CHECK_FN(self, self.params.execution.context.symbol, signal, averagePrice, currentCandleTimestamp, self.params.execution.context.backtest);
@@ -5412,14 +5529,14 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                 if (currentDistance > 0) {
                     // Moving towards TP (use trailing TP if set)
                     const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
-                    const tpDistance = signal.priceOpen - effectiveTakeProfit;
+                    const tpDistance = effectivePriceOpen - effectiveTakeProfit;
                     const progressPercent = (currentDistance / tpDistance) * 100;
                     await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
                 if (currentDistance < 0) {
                     // Moving towards SL (use trailing SL if set)
                     const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
-                    const slDistance = effectiveStopLoss - signal.priceOpen;
+                    const slDistance = effectiveStopLoss - effectivePriceOpen;
                     const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                     await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
@@ -5617,6 +5734,7 @@ class ClientStrategy {
             return false;
         }
         const signal = this._pendingSignal;
+        const effectivePriceOpen = getEffectivePriceOpen(signal);
         // Calculate breakeven threshold based on slippage and fees
         // Need to cover: entry slippage + entry fee + exit slippage + exit fee
         // Total: (slippage + fee) * 2 transactions
@@ -5626,52 +5744,52 @@ class ClientStrategy {
             const trailingStopLoss = signal._trailingPriceStopLoss;
             if (signal.position === "long") {
                 // LONG: trailing SL is positive if it's above entry (in profit zone)
-                const isPositiveTrailing = trailingStopLoss > signal.priceOpen;
+                const isPositiveTrailing = trailingStopLoss > effectivePriceOpen;
                 if (isPositiveTrailing) {
                     // Trailing stop is already protecting profit - breakeven achieved
                     return true;
                 }
                 // Trailing stop is negative (below entry)
                 // Check if we can upgrade it to breakeven
-                const thresholdPrice = signal.priceOpen * (1 + breakevenThresholdPercent / 100);
+                const thresholdPrice = effectivePriceOpen * (1 + breakevenThresholdPercent / 100);
                 const isThresholdReached = currentPrice >= thresholdPrice;
-                const breakevenPrice = signal.priceOpen;
+                const breakevenPrice = effectivePriceOpen;
                 // Can upgrade to breakeven if threshold reached and breakeven is better than current trailing SL
                 return isThresholdReached && breakevenPrice > trailingStopLoss;
             }
             else {
                 // SHORT: trailing SL is positive if it's below entry (in profit zone)
-                const isPositiveTrailing = trailingStopLoss < signal.priceOpen;
+                const isPositiveTrailing = trailingStopLoss < effectivePriceOpen;
                 if (isPositiveTrailing) {
                     // Trailing stop is already protecting profit - breakeven achieved
                     return true;
                 }
                 // Trailing stop is negative (above entry)
                 // Check if we can upgrade it to breakeven
-                const thresholdPrice = signal.priceOpen * (1 - breakevenThresholdPercent / 100);
+                const thresholdPrice = effectivePriceOpen * (1 - breakevenThresholdPercent / 100);
                 const isThresholdReached = currentPrice <= thresholdPrice;
-                const breakevenPrice = signal.priceOpen;
+                const breakevenPrice = effectivePriceOpen;
                 // Can upgrade to breakeven if threshold reached and breakeven is better than current trailing SL
                 return isThresholdReached && breakevenPrice < trailingStopLoss;
             }
         }
         // No trailing stop set - proceed with normal breakeven logic
         const currentStopLoss = signal.priceStopLoss;
-        const breakevenPrice = signal.priceOpen;
+        const breakevenPrice = effectivePriceOpen;
         // Calculate threshold price
         let thresholdPrice;
         let isThresholdReached;
         let canMoveToBreakeven;
         if (signal.position === "long") {
             // LONG: threshold reached when price goes UP by breakevenThresholdPercent from entry
-            thresholdPrice = signal.priceOpen * (1 + breakevenThresholdPercent / 100);
+            thresholdPrice = effectivePriceOpen * (1 + breakevenThresholdPercent / 100);
             isThresholdReached = currentPrice >= thresholdPrice;
             // Can move to breakeven only if threshold reached and SL is below entry
             canMoveToBreakeven = isThresholdReached && currentStopLoss < breakevenPrice;
         }
         else {
             // SHORT: threshold reached when price goes DOWN by breakevenThresholdPercent from entry
-            thresholdPrice = signal.priceOpen * (1 - breakevenThresholdPercent / 100);
+            thresholdPrice = effectivePriceOpen * (1 - breakevenThresholdPercent / 100);
             isThresholdReached = currentPrice <= thresholdPrice;
             // Can move to breakeven only if threshold reached and SL is above entry
             canMoveToBreakeven = isThresholdReached && currentStopLoss > breakevenPrice;
@@ -5754,6 +5872,8 @@ class ClientStrategy {
                 backtest: this.params.execution.context.backtest,
                 cancelId: cancelledSignal.cancelId,
                 timestamp: currentTime,
+                totalEntries: cancelledSignal._entry?.length ?? 1,
+                originalPriceOpen: cancelledSignal.priceOpen,
             });
             // Call onCancel callback
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -5794,6 +5914,8 @@ class ClientStrategy {
                 backtest: this.params.execution.context.backtest,
                 closeId: closedSignal.closeId,
                 timestamp: currentTime,
+                totalEntries: closedSignal._entry?.length ?? 1,
+                originalPriceOpen: closedSignal.priceOpen,
             });
             // Call onClose callback
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -5874,8 +5996,10 @@ class ClientStrategy {
                 priceStopLoss: publicSignalForCommit.priceStopLoss,
                 originalPriceTakeProfit: publicSignalForCommit.originalPriceTakeProfit,
                 originalPriceStopLoss: publicSignalForCommit.originalPriceStopLoss,
+                originalPriceOpen: publicSignalForCommit.originalPriceOpen,
                 scheduledAt: publicSignalForCommit.scheduledAt,
                 pendingAt: publicSignalForCommit.pendingAt,
+                totalEntries: publicSignalForCommit.totalEntries,
             });
             // Call onOpen callback
             await CALL_OPEN_CALLBACKS_FN(this, this.params.execution.context.symbol, pendingSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -6006,6 +6130,8 @@ class ClientStrategy {
                 backtest: true,
                 cancelId: cancelledSignal.cancelId,
                 timestamp: closeTimestamp,
+                totalEntries: cancelledSignal._entry?.length ?? 1,
+                originalPriceOpen: cancelledSignal.priceOpen,
             });
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             const cancelledResult = {
@@ -6043,6 +6169,8 @@ class ClientStrategy {
                 backtest: true,
                 closeId: closedSignal.closeId,
                 timestamp: closeTimestamp,
+                totalEntries: closedSignal._entry?.length ?? 1,
+                originalPriceOpen: closedSignal.priceOpen,
             });
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
@@ -6430,16 +6558,19 @@ class ClientStrategy {
             throw new Error(`ClientStrategy partialProfit: currentPrice must be a positive finite number, got ${currentPrice}`);
         }
         // Validation: currentPrice must be moving toward TP (profit direction)
-        if (this._pendingSignal.position === "long") {
-            // For LONG: currentPrice must be higher than priceOpen (moving toward TP)
-            if (currentPrice <= this._pendingSignal.priceOpen) {
-                throw new Error(`ClientStrategy partialProfit: For LONG position, currentPrice (${currentPrice}) must be > priceOpen (${this._pendingSignal.priceOpen})`);
+        {
+            const effectivePriceOpen = getEffectivePriceOpen(this._pendingSignal);
+            if (this._pendingSignal.position === "long") {
+                // For LONG: currentPrice must be higher than effectivePriceOpen (moving toward TP)
+                if (currentPrice <= effectivePriceOpen) {
+                    throw new Error(`ClientStrategy partialProfit: For LONG position, currentPrice (${currentPrice}) must be > effectivePriceOpen (${effectivePriceOpen})`);
+                }
             }
-        }
-        else {
-            // For SHORT: currentPrice must be lower than priceOpen (moving toward TP)
-            if (currentPrice >= this._pendingSignal.priceOpen) {
-                throw new Error(`ClientStrategy partialProfit: For SHORT position, currentPrice (${currentPrice}) must be < priceOpen (${this._pendingSignal.priceOpen})`);
+            else {
+                // For SHORT: currentPrice must be lower than effectivePriceOpen (moving toward TP)
+                if (currentPrice >= effectivePriceOpen) {
+                    throw new Error(`ClientStrategy partialProfit: For SHORT position, currentPrice (${currentPrice}) must be < effectivePriceOpen (${effectivePriceOpen})`);
+                }
             }
         }
         // Check if currentPrice already crossed take profit level
@@ -6562,16 +6693,19 @@ class ClientStrategy {
             throw new Error(`ClientStrategy partialLoss: currentPrice must be a positive finite number, got ${currentPrice}`);
         }
         // Validation: currentPrice must be moving toward SL (loss direction)
-        if (this._pendingSignal.position === "long") {
-            // For LONG: currentPrice must be lower than priceOpen (moving toward SL)
-            if (currentPrice >= this._pendingSignal.priceOpen) {
-                throw new Error(`ClientStrategy partialLoss: For LONG position, currentPrice (${currentPrice}) must be < priceOpen (${this._pendingSignal.priceOpen})`);
+        {
+            const effectivePriceOpen = getEffectivePriceOpen(this._pendingSignal);
+            if (this._pendingSignal.position === "long") {
+                // For LONG: currentPrice must be lower than effectivePriceOpen (moving toward SL)
+                if (currentPrice >= effectivePriceOpen) {
+                    throw new Error(`ClientStrategy partialLoss: For LONG position, currentPrice (${currentPrice}) must be < effectivePriceOpen (${effectivePriceOpen})`);
+                }
             }
-        }
-        else {
-            // For SHORT: currentPrice must be higher than priceOpen (moving toward SL)
-            if (currentPrice <= this._pendingSignal.priceOpen) {
-                throw new Error(`ClientStrategy partialLoss: For SHORT position, currentPrice (${currentPrice}) must be > priceOpen (${this._pendingSignal.priceOpen})`);
+            else {
+                // For SHORT: currentPrice must be higher than effectivePriceOpen (moving toward SL)
+                if (currentPrice <= effectivePriceOpen) {
+                    throw new Error(`ClientStrategy partialLoss: For SHORT position, currentPrice (${currentPrice}) must be > effectivePriceOpen (${effectivePriceOpen})`);
+                }
             }
         }
         // Check if currentPrice already crossed stop loss level
@@ -6692,7 +6826,7 @@ class ClientStrategy {
         }
         // Check for conflict with existing trailing take profit
         const signal = this._pendingSignal;
-        const breakevenPrice = signal.priceOpen;
+        const breakevenPrice = getEffectivePriceOpen(signal);
         const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
         if (signal.position === "long" && breakevenPrice >= effectiveTakeProfit) {
             // LONG: Breakeven SL would be at or above current TP - invalid configuration
@@ -6844,14 +6978,15 @@ class ClientStrategy {
         }
         // Calculate what the new stop loss would be
         const signal = this._pendingSignal;
-        const slDistancePercent = Math.abs((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen * 100);
+        const effectivePriceOpen = getEffectivePriceOpen(signal);
+        const slDistancePercent = Math.abs((effectivePriceOpen - signal.priceStopLoss) / effectivePriceOpen * 100);
         const newSlDistancePercent = slDistancePercent + percentShift;
         let newStopLoss;
         if (signal.position === "long") {
-            newStopLoss = signal.priceOpen * (1 - newSlDistancePercent / 100);
+            newStopLoss = effectivePriceOpen * (1 - newSlDistancePercent / 100);
         }
         else {
-            newStopLoss = signal.priceOpen * (1 + newSlDistancePercent / 100);
+            newStopLoss = effectivePriceOpen * (1 + newSlDistancePercent / 100);
         }
         // Check for price intrusion before executing trailing logic
         if (signal.position === "long" && currentPrice < newStopLoss) {
@@ -7017,14 +7152,15 @@ class ClientStrategy {
         }
         // Calculate what the new take profit would be
         const signal = this._pendingSignal;
-        const tpDistancePercent = Math.abs((signal.priceTakeProfit - signal.priceOpen) / signal.priceOpen * 100);
+        const effectivePriceOpen = getEffectivePriceOpen(signal);
+        const tpDistancePercent = Math.abs((signal.priceTakeProfit - effectivePriceOpen) / effectivePriceOpen * 100);
         const newTpDistancePercent = tpDistancePercent + percentShift;
         let newTakeProfit;
         if (signal.position === "long") {
-            newTakeProfit = signal.priceOpen * (1 + newTpDistancePercent / 100);
+            newTakeProfit = effectivePriceOpen * (1 + newTpDistancePercent / 100);
         }
         else {
-            newTakeProfit = signal.priceOpen * (1 - newTpDistancePercent / 100);
+            newTakeProfit = effectivePriceOpen * (1 - newTpDistancePercent / 100);
         }
         // Check for price intrusion before executing trailing logic
         if (signal.position === "long" && currentPrice > newTakeProfit) {
@@ -7106,6 +7242,70 @@ class ClientStrategy {
         });
         return true;
     }
+    /**
+     * Adds a new averaging entry to an open position (DCA — Dollar Cost Averaging).
+     *
+     * Appends currentPrice to the _entry array. The effective entry price used in all
+     * distance and PNL calculations becomes the simple arithmetic mean of all _entry prices.
+     * Original priceOpen is preserved unchanged for identity/audit purposes.
+     *
+     * Rejection rules (returns false without throwing):
+     * - LONG: currentPrice >= last entry price (must average down, not up or equal)
+     * - SHORT: currentPrice <= last entry price (must average down, not up or equal)
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param currentPrice - New entry price to add to the averaging history
+     * @param backtest - Whether running in backtest mode
+     * @returns Promise<boolean> - true if entry added, false if rejected by direction check
+     */
+    async averageBuy(symbol, currentPrice, backtest) {
+        this.params.logger.debug("ClientStrategy averageBuy", {
+            symbol,
+            currentPrice,
+            hasPendingSignal: this._pendingSignal !== null,
+        });
+        // Validation: must have pending signal
+        if (!this._pendingSignal) {
+            throw new Error(`ClientStrategy averageBuy: No pending signal exists for symbol=${symbol}`);
+        }
+        // Validation: currentPrice must be valid
+        if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0) {
+            throw new Error(`ClientStrategy averageBuy: currentPrice must be a positive finite number, got ${currentPrice}`);
+        }
+        // Reject if any partial closes have already been executed
+        if (this._pendingSignal._partial && this._pendingSignal._partial.length > 0) {
+            this.params.logger.debug("ClientStrategy averageBuy: rejected — partial closes already executed", {
+                symbol,
+                partialCount: this._pendingSignal._partial.length,
+            });
+            return false;
+        }
+        // Execute averaging logic
+        const result = AVERAGE_BUY_FN(this, this._pendingSignal, currentPrice);
+        if (!result) {
+            return false;
+        }
+        // Persist updated signal state
+        this.params.logger.debug("ClientStrategy setPendingSignal (inline)", {
+            pendingSignal: this._pendingSignal,
+        });
+        // Call onWrite callback for testing persist storage
+        if (this.params.callbacks?.onWrite) {
+            this.params.callbacks.onWrite(this.params.execution.context.symbol, TO_PUBLIC_SIGNAL(this._pendingSignal), backtest);
+        }
+        if (!backtest) {
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
+        }
+        // Queue commit event for processing in tick()/backtest() with proper timestamp
+        this._commitQueue.push({
+            action: "average-buy",
+            symbol,
+            backtest,
+            currentPrice,
+            totalEntries: this._pendingSignal._entry?.length ?? 1,
+        });
+        return true;
+    }
 }
 
 const RISK_METHOD_NAME_GET_DATA = "RiskUtils.getData";
@@ -8230,6 +8430,27 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.activateScheduled(symbol, backtest, activateId);
         };
+        /**
+         * Adds a new DCA entry to the active pending signal.
+         *
+         * Delegates to ClientStrategy.averageBuy() with current execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - New entry price to add to the averaging history
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if entry added, false if rejected
+         */
+        this.averageBuy = async (backtest, symbol, currentPrice, context) => {
+            this.loggerService.log("strategyConnectionService averageBuy", {
+                symbol,
+                context,
+                currentPrice,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.averageBuy(symbol, currentPrice, backtest);
+        };
     }
 }
 
@@ -8703,11 +8924,13 @@ const TO_RISK_SIGNAL = (signal, currentPrice) => {
         : 0;
     return {
         ...structuredClone(signal),
+        totalEntries: 1,
         priceOpen: signal.priceOpen ?? currentPrice,
         priceStopLoss: hasTrailingSL ? signal._trailingPriceStopLoss : signal.priceStopLoss,
         priceTakeProfit: hasTrailingTP ? signal._trailingPriceTakeProfit : signal.priceTakeProfit,
         originalPriceStopLoss: signal.priceStopLoss,
         originalPriceTakeProfit: signal.priceTakeProfit,
+        originalPriceOpen: signal.priceOpen ?? currentPrice,
         partialExecuted,
     };
 };
@@ -11575,6 +11798,28 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.activateScheduled(backtest, symbol, context, activateId);
         };
+        /**
+         * Adds a new DCA entry to the active pending signal.
+         *
+         * Validates strategy existence and delegates to connection service
+         * to add a new averaging entry to the position.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - New entry price to add to the averaging history
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if entry added, false if rejected
+         */
+        this.averageBuy = async (backtest, symbol, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService averageBuy", {
+                symbol,
+                currentPrice,
+                context,
+                backtest,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.averageBuy(backtest, symbol, currentPrice, context);
+        };
     }
 }
 
@@ -14122,6 +14367,18 @@ const backtest_columns = [
         format: (data) => `${data.signal.originalPriceStopLoss.toFixed(8)} USD`,
         isVisible: () => true,
     },
+    {
+        key: "originalPriceOpen",
+        label: "Original Entry",
+        format: (data) => `${data.signal.originalPriceOpen.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "totalEntries",
+        label: "DCA Entries",
+        format: (data) => String(data.signal.totalEntries),
+        isVisible: () => true,
+    },
     {
         key: "pnl",
         label: "PNL (net)",
@@ -14409,6 +14666,20 @@ const live_columns = [
             : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "originalPriceOpen",
+        label: "Original Entry",
+        format: (data) => data.originalPriceOpen !== undefined
+            ? `${data.originalPriceOpen.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalEntries",
+        label: "DCA Entries",
+        format: (data) => data.totalEntries !== undefined ? String(data.totalEntries) : "N/A",
+        isVisible: () => true,
+    },
     {
         key: "partialExecuted",
         label: "Partial Executed %",
@@ -14573,6 +14844,18 @@ const partial_columns = [
         format: (data) => (data.originalPriceStopLoss ? `${data.originalPriceStopLoss.toFixed(8)} USD` : "N/A"),
         isVisible: () => true,
     },
+    {
+        key: "originalPriceOpen",
+        label: "Original Entry",
+        format: (data) => (data.originalPriceOpen ? `${data.originalPriceOpen.toFixed(8)} USD` : "N/A"),
+        isVisible: () => true,
+    },
+    {
+        key: "totalEntries",
+        label: "DCA Entries",
+        format: (data) => (data.totalEntries !== undefined ? String(data.totalEntries) : "N/A"),
+        isVisible: () => true,
+    },
     {
         key: "partialExecuted",
         label: "Partial Executed %",
@@ -14707,6 +14990,18 @@ const breakeven_columns = [
         format: (data) => (data.originalPriceStopLoss ? `${data.originalPriceStopLoss.toFixed(8)} USD` : "N/A"),
         isVisible: () => true,
     },
+    {
+        key: "originalPriceOpen",
+        label: "Original Entry",
+        format: (data) => (data.originalPriceOpen ? `${data.originalPriceOpen.toFixed(8)} USD` : "N/A"),
+        isVisible: () => true,
+    },
+    {
+        key: "totalEntries",
+        label: "DCA Entries",
+        format: (data) => (data.totalEntries !== undefined ? String(data.totalEntries) : "N/A"),
+        isVisible: () => true,
+    },
     {
         key: "partialExecuted",
         label: "Partial Executed %",
@@ -14977,6 +15272,22 @@ const risk_columns = [
             : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "originalPriceOpen",
+        label: "Original Entry",
+        format: (data) => data.currentSignal.originalPriceOpen !== undefined
+            ? `${data.currentSignal.originalPriceOpen.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalEntries",
+        label: "DCA Entries",
+        format: (data) => data.currentSignal.totalEntries !== undefined
+            ? String(data.currentSignal.totalEntries)
+            : "N/A",
+        isVisible: () => true,
+    },
     {
         key: "partialExecuted",
         label: "Partial Executed %",
@@ -15151,6 +15462,20 @@ const schedule_columns = [
             : "N/A",
         isVisible: () => true,
     },
+    {
+        key: "originalPriceOpen",
+        label: "Original Entry",
+        format: (data) => data.originalPriceOpen !== undefined
+            ? `${data.originalPriceOpen.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalEntries",
+        label: "DCA Entries",
+        format: (data) => data.totalEntries !== undefined ? String(data.totalEntries) : "N/A",
+        isVisible: () => true,
+    },
     {
         key: "partialExecuted",
         label: "Partial Executed %",
@@ -17240,6 +17565,8 @@ let ReportStorage$5 = class ReportStorage {
             priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalEntries: data.signal.totalEntries,
+            originalPriceOpen: data.signal.originalPriceOpen,
             partialExecuted: data.signal.partialExecuted,
             scheduledAt: data.signal.scheduledAt,
         });
@@ -17269,6 +17596,8 @@ let ReportStorage$5 = class ReportStorage {
             priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalEntries: data.signal.totalEntries,
+            originalPriceOpen: data.signal.originalPriceOpen,
             partialExecuted: data.signal.partialExecuted,
             duration: durationMin,
             pendingAt: data.signal.pendingAt,
@@ -17301,6 +17630,8 @@ let ReportStorage$5 = class ReportStorage {
             priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalEntries: data.signal.totalEntries,
+            originalPriceOpen: data.signal.originalPriceOpen,
             partialExecuted: data.signal.partialExecuted,
             closeTimestamp: data.closeTimestamp,
             duration: durationMin,
@@ -20446,6 +20777,8 @@ let ReportStorage$3 = class ReportStorage {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            totalEntries: data.totalEntries,
+            originalPriceOpen: data.originalPriceOpen,
             partialExecuted: data.partialExecuted,
             note: data.note,
             pendingAt: data.pendingAt,
@@ -20480,6 +20813,8 @@ let ReportStorage$3 = class ReportStorage {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            totalEntries: data.totalEntries,
+            originalPriceOpen: data.originalPriceOpen,
             partialExecuted: data.partialExecuted,
             note: data.note,
             pendingAt: data.pendingAt,
@@ -21579,6 +21914,8 @@ let ReportStorage$2 = class ReportStorage {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            totalEntries: data.totalEntries,
+            originalPriceOpen: data.originalPriceOpen,
             partialExecuted: data.partialExecuted,
             note: data.note,
             pendingAt: data.pendingAt,
@@ -23582,6 +23919,8 @@ class ScheduleReportService {
                     priceStopLoss: data.signal?.priceStopLoss,
                     originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
                     originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    totalEntries: data.signal?.totalEntries,
+                    originalPriceOpen: data.signal?.originalPriceOpen,
                     partialExecuted: data.signal?.partialExecuted,
                     pendingAt: data.signal?.pendingAt,
                     minuteEstimatedTime: data.signal?.minuteEstimatedTime,
@@ -23626,6 +23965,8 @@ class ScheduleReportService {
                     priceStopLoss: data.signal?.priceStopLoss,
                     originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
                     originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    totalEntries: data.signal?.totalEntries,
+                    originalPriceOpen: data.signal?.originalPriceOpen,
                     partialExecuted: data.signal?.partialExecuted,
                     scheduledAt: data.signal?.scheduledAt,
                     pendingAt: data.signal?.pendingAt,
@@ -24103,6 +24444,8 @@ class PartialReportService {
                 priceStopLoss: data.data.priceStopLoss,
                 originalPriceTakeProfit: data.data.originalPriceTakeProfit,
                 originalPriceStopLoss: data.data.originalPriceStopLoss,
+                totalEntries: data.data.totalEntries,
+                originalPriceOpen: data.data.originalPriceOpen,
                 partialExecuted: data.data.partialExecuted,
                 _partial: data.data._partial,
                 note: data.data.note,
@@ -24144,6 +24487,8 @@ class PartialReportService {
                 priceStopLoss: data.data.priceStopLoss,
                 originalPriceTakeProfit: data.data.originalPriceTakeProfit,
                 originalPriceStopLoss: data.data.originalPriceStopLoss,
+                totalEntries: data.data.totalEntries,
+                originalPriceOpen: data.data.originalPriceOpen,
                 partialExecuted: data.data.partialExecuted,
                 _partial: data.data._partial,
                 note: data.data.note,
@@ -24266,6 +24611,8 @@ class BreakevenReportService {
                 priceStopLoss: data.data.priceStopLoss,
                 originalPriceTakeProfit: data.data.originalPriceTakeProfit,
                 originalPriceStopLoss: data.data.originalPriceStopLoss,
+                totalEntries: data.data.totalEntries,
+                originalPriceOpen: data.data.originalPriceOpen,
                 partialExecuted: data.data.partialExecuted,
                 _partial: data.data._partial,
                 note: data.data.note,
@@ -24574,7 +24921,7 @@ class StrategyReportService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.partialProfit = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.partialProfit = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyReportService partialProfit", {
                 symbol,
                 percentToClose,
@@ -24606,6 +24953,8 @@ class StrategyReportService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             }, {
@@ -24635,7 +24984,7 @@ class StrategyReportService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.partialLoss = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.partialLoss = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyReportService partialLoss", {
                 symbol,
                 percentToClose,
@@ -24667,6 +25016,8 @@ class StrategyReportService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             }, {
@@ -24696,7 +25047,7 @@ class StrategyReportService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.trailingStop = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.trailingStop = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyReportService trailingStop", {
                 symbol,
                 percentShift,
@@ -24728,6 +25079,8 @@ class StrategyReportService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             }, {
@@ -24757,7 +25110,7 @@ class StrategyReportService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.trailingTake = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.trailingTake = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyReportService trailingTake", {
                 symbol,
                 percentShift,
@@ -24789,6 +25142,8 @@ class StrategyReportService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             }, {
@@ -24817,7 +25172,7 @@ class StrategyReportService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.breakeven = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.breakeven = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyReportService breakeven", {
                 symbol,
                 currentPrice,
@@ -24847,6 +25202,8 @@ class StrategyReportService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             }, {
@@ -24876,7 +25233,7 @@ class StrategyReportService {
          * @param pendingAt - Pending timestamp in milliseconds
          * @param activateId - Optional identifier for the activation reason
          */
-        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, activateId) => {
+        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen, activateId) => {
             this.loggerService.log("strategyReportService activateScheduled", {
                 symbol,
                 currentPrice,
@@ -24908,6 +25265,8 @@ class StrategyReportService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             }, {
@@ -24919,6 +25278,71 @@ class StrategyReportService {
                 walkerName: "",
             });
         };
+        /**
+         * Logs an average-buy (DCA) event when a new averaging entry is added to an open position.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param currentPrice - Price at which the new averaging entry was executed
+         * @param effectivePriceOpen - Averaged entry price after this addition
+         * @param totalEntries - Total number of DCA entries after this addition
+         * @param isBacktest - Whether this is a backtest or live trading event
+         * @param context - Strategy context with strategyName, exchangeName, frameName
+         * @param timestamp - Timestamp from StrategyCommitContract (execution context time)
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Original entry price (unchanged by averaging)
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         */
+        this.averageBuy = async (symbol, currentPrice, effectivePriceOpen, totalEntries, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, originalPriceOpen) => {
+            this.loggerService.log("strategyReportService averageBuy", {
+                symbol,
+                currentPrice,
+                effectivePriceOpen,
+                totalEntries,
+                isBacktest,
+            });
+            if (!this.subscribe.hasValue()) {
+                return;
+            }
+            const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+            });
+            if (!pendingRow) {
+                return;
+            }
+            const createdAt = new Date(timestamp).toISOString();
+            await Report.writeData("strategy", {
+                action: "average-buy",
+                currentPrice,
+                effectivePriceOpen,
+                totalEntries,
+                symbol,
+                timestamp,
+                createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                originalPriceOpen,
+                scheduledAt,
+                pendingAt,
+            }, {
+                signalId: pendingRow.id,
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+                strategyName: context.strategyName,
+                symbol,
+                walkerName: "",
+            });
+        };
         /**
          * Initializes the service for event logging.
          *
@@ -24949,43 +25373,50 @@ class StrategyReportService {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unPartialLoss = strategyCommitSubject
                 .filter(({ action }) => action === "partial-loss")
                 .connect(async (event) => await this.partialLoss(event.symbol, event.percentToClose, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unTrailingStop = strategyCommitSubject
                 .filter(({ action }) => action === "trailing-stop")
                 .connect(async (event) => await this.trailingStop(event.symbol, event.percentShift, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unTrailingTake = strategyCommitSubject
                 .filter(({ action }) => action === "trailing-take")
                 .connect(async (event) => await this.trailingTake(event.symbol, event.percentShift, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unBreakeven = strategyCommitSubject
                 .filter(({ action }) => action === "breakeven")
                 .connect(async (event) => await this.breakeven(event.symbol, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unActivateScheduled = strategyCommitSubject
                 .filter(({ action }) => action === "activate-scheduled")
                 .connect(async (event) => await this.activateScheduled(event.symbol, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.activateId));
-            const disposeFn = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled());
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen, event.activateId));
+            const unAverageBuy = strategyCommitSubject
+                .filter(({ action }) => action === "average-buy")
+                .connect(async (event) => await this.averageBuy(event.symbol, event.currentPrice, event.effectivePriceOpen, event.totalEntries, event.backtest, {
+                exchangeName: event.exchangeName,
+                frameName: event.frameName,
+                strategyName: event.strategyName,
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.originalPriceOpen));
+            const disposeFn = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled(), () => unAverageBuy());
             return () => {
                 disposeFn();
                 this.subscribe.clear();
@@ -25117,6 +25548,7 @@ class ReportStorage {
                 trailingTakeCount: 0,
                 breakevenCount: 0,
                 activateScheduledCount: 0,
+                averageBuyCount: 0,
             };
         }
         return {
@@ -25130,6 +25562,7 @@ class ReportStorage {
             trailingTakeCount: this._eventList.filter(e => e.action === "trailing-take").length,
             breakevenCount: this._eventList.filter(e => e.action === "breakeven").length,
             activateScheduledCount: this._eventList.filter(e => e.action === "activate-scheduled").length,
+            averageBuyCount: this._eventList.filter(e => e.action === "average-buy").length,
         };
     }
     /**
@@ -25179,6 +25612,7 @@ class ReportStorage {
             `- Trailing take: ${stats.trailingTakeCount}`,
             `- Breakeven: ${stats.breakevenCount}`,
             `- Activate scheduled: ${stats.activateScheduledCount}`,
+            `- Average buy: ${stats.averageBuyCount}`,
         ].join("\n");
     }
     /**
@@ -25366,7 +25800,7 @@ class StrategyMarkdownService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.partialProfit = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.partialProfit = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyMarkdownService partialProfit", {
                 symbol,
                 percentToClose,
@@ -25404,6 +25838,8 @@ class StrategyMarkdownService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             });
@@ -25426,7 +25862,7 @@ class StrategyMarkdownService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.partialLoss = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.partialLoss = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyMarkdownService partialLoss", {
                 symbol,
                 percentToClose,
@@ -25464,6 +25900,8 @@ class StrategyMarkdownService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             });
@@ -25486,7 +25924,7 @@ class StrategyMarkdownService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.trailingStop = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.trailingStop = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyMarkdownService trailingStop", {
                 symbol,
                 percentShift,
@@ -25524,6 +25962,8 @@ class StrategyMarkdownService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             });
@@ -25546,7 +25986,7 @@ class StrategyMarkdownService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.trailingTake = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.trailingTake = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyMarkdownService trailingTake", {
                 symbol,
                 percentShift,
@@ -25584,6 +26024,8 @@ class StrategyMarkdownService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             });
@@ -25605,7 +26047,7 @@ class StrategyMarkdownService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          */
-        this.breakeven = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
+        this.breakeven = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen) => {
             this.loggerService.log("strategyMarkdownService breakeven", {
                 symbol,
                 currentPrice,
@@ -25641,6 +26083,8 @@ class StrategyMarkdownService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
                 scheduledAt,
                 pendingAt,
             });
@@ -25663,7 +26107,7 @@ class StrategyMarkdownService {
          * @param pendingAt - Pending timestamp in milliseconds
          * @param activateId - Optional identifier for the activation reason
          */
-        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, activateId) => {
+        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen, activateId) => {
             this.loggerService.log("strategyMarkdownService activateScheduled", {
                 symbol,
                 currentPrice,
@@ -25701,6 +26145,72 @@ class StrategyMarkdownService {
                 priceStopLoss,
                 originalPriceTakeProfit,
                 originalPriceStopLoss,
+                originalPriceOpen,
+                totalEntries,
+                scheduledAt,
+                pendingAt,
+            });
+        };
+        /**
+         * Records an average-buy (DCA) event when a new averaging entry is added to an open position.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param currentPrice - Price at which the new averaging entry was executed
+         * @param effectivePriceOpen - Averaged entry price after this addition
+         * @param totalEntries - Total number of DCA entries after this addition
+         * @param isBacktest - Whether this is a backtest or live trading event
+         * @param context - Strategy context with strategyName, exchangeName, frameName
+         * @param timestamp - Timestamp from StrategyCommitContract (execution context time)
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Original entry price (unchanged by averaging)
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         */
+        this.averageBuy = async (symbol, currentPrice, effectivePriceOpen, totalEntries, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, originalPriceOpen) => {
+            this.loggerService.log("strategyMarkdownService averageBuy", {
+                symbol,
+                currentPrice,
+                effectivePriceOpen,
+                totalEntries,
+                isBacktest,
+            });
+            if (!this.subscribe.hasValue()) {
+                return;
+            }
+            const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+            });
+            if (!pendingRow) {
+                return;
+            }
+            const createdAt = new Date(timestamp).toISOString();
+            const storage = this.getStorage(symbol, context.strategyName, context.exchangeName, context.frameName, isBacktest);
+            storage.addEvent({
+                timestamp,
+                symbol,
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+                signalId: pendingRow.id,
+                action: "average-buy",
+                currentPrice,
+                effectivePriceOpen,
+                totalEntries,
+                createdAt,
+                backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                originalPriceOpen,
                 scheduledAt,
                 pendingAt,
             });
@@ -25849,43 +26359,50 @@ class StrategyMarkdownService {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unPartialLoss = strategyCommitSubject
                 .filter(({ action }) => action === "partial-loss")
                 .connect(async (event) => await this.partialLoss(event.symbol, event.percentToClose, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unTrailingStop = strategyCommitSubject
                 .filter(({ action }) => action === "trailing-stop")
                 .connect(async (event) => await this.trailingStop(event.symbol, event.percentShift, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unTrailingTake = strategyCommitSubject
                 .filter(({ action }) => action === "trailing-take")
                 .connect(async (event) => await this.trailingTake(event.symbol, event.percentShift, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unBreakeven = strategyCommitSubject
                 .filter(({ action }) => action === "breakeven")
                 .connect(async (event) => await this.breakeven(event.symbol, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen));
             const unActivateScheduled = strategyCommitSubject
                 .filter(({ action }) => action === "activate-scheduled")
                 .connect(async (event) => await this.activateScheduled(event.symbol, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.activateId));
-            const disposeFn = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled());
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen, event.activateId));
+            const unAverageBuy = strategyCommitSubject
+                .filter(({ action }) => action === "average-buy")
+                .connect(async (event) => await this.averageBuy(event.symbol, event.currentPrice, event.effectivePriceOpen, event.totalEntries, event.backtest, {
+                exchangeName: event.exchangeName,
+                frameName: event.frameName,
+                strategyName: event.strategyName,
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.originalPriceOpen));
+            const disposeFn = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled(), () => unAverageBuy());
             return () => {
                 disposeFn();
                 this.subscribe.clear();
@@ -27691,6 +28208,7 @@ const TRAILING_STOP_METHOD_NAME = "strategy.commitTrailingStop";
 const TRAILING_PROFIT_METHOD_NAME = "strategy.commitTrailingTake";
 const BREAKEVEN_METHOD_NAME = "strategy.commitBreakeven";
 const ACTIVATE_SCHEDULED_METHOD_NAME = "strategy.commitActivateScheduled";
+const AVERAGE_BUY_METHOD_NAME = "strategy.commitAverageBuy";
 /**
  * Cancels the scheduled signal without stopping the strategy.
  *
@@ -28043,6 +28561,45 @@ async function commitActivateScheduled(symbol, activateId) {
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     await bt.strategyCoreService.activateScheduled(isBacktest, symbol, { exchangeName, frameName, strategyName }, activateId);
 }
+/**
+ * Adds a new DCA entry to the active pending signal.
+ *
+ * Adds a new averaging entry at the current market price to the position's
+ * entry history. Updates effectivePriceOpen (mean of all entries) and emits
+ * an average-buy commit event.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ * Automatically fetches current price via getAveragePrice.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise<boolean> - true if entry added, false if rejected
+ *
+ * @example
+ * ```typescript
+ * import { commitAverageBuy } from "backtest-kit";
+ *
+ * // Add DCA entry at current market price
+ * const success = await commitAverageBuy("BTCUSDT");
+ * if (success) {
+ *   console.log("DCA entry added");
+ * }
+ * ```
+ */
+async function commitAverageBuy(symbol) {
+    bt.loggerService.info(AVERAGE_BUY_METHOD_NAME, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitAverageBuy requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitAverageBuy requires a method context");
+    }
+    const currentPrice = await getAveragePrice(symbol);
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.averageBuy(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+}
 
 const STOP_STRATEGY_METHOD_NAME = "control.stopStrategy";
 /**
@@ -30323,6 +30880,7 @@ const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.commitPartialLoss";
 const BACKTEST_METHOD_NAME_TRAILING_STOP = "BacktestUtils.commitTrailingStop";
 const BACKTEST_METHOD_NAME_TRAILING_PROFIT = "BacktestUtils.commitTrailingTake";
 const BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED = "Backtest.commitActivateScheduled";
+const BACKTEST_METHOD_NAME_AVERAGE_BUY = "Backtest.commitAverageBuy";
 const BACKTEST_METHOD_NAME_GET_DATA = "BacktestUtils.getData";
 /**
  * Internal task function that runs backtest and handles completion.
@@ -31219,6 +31777,49 @@ class BacktestUtils {
             }
             await bt.strategyCoreService.activateScheduled(true, symbol, context, activateId);
         };
+        /**
+         * Adds a new DCA entry to the active pending signal.
+         *
+         * Adds a new averaging entry at currentPrice to the position's entry history.
+         * Updates effectivePriceOpen (mean of all entries) and emits average-buy commit event.
+         *
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - New entry price to add to the averaging history
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if entry added, false if rejected
+         *
+         * @example
+         * ```typescript
+         * // Add DCA entry at current price
+         * const success = await Backtest.commitAverageBuy("BTCUSDT", 42000, {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance",
+         *   frameName: "1h"
+         * });
+         * if (success) {
+         *   console.log('DCA entry added');
+         * }
+         * ```
+         */
+        this.commitAverageBuy = async (symbol, currentPrice, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_AVERAGE_BUY, {
+                symbol,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_AVERAGE_BUY);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_AVERAGE_BUY);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_AVERAGE_BUY);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_AVERAGE_BUY));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_AVERAGE_BUY));
+            }
+            return await bt.strategyCoreService.averageBuy(true, symbol, currentPrice, context);
+        };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
          *
@@ -31395,6 +31996,7 @@ const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.commitPartialLoss";
 const LIVE_METHOD_NAME_TRAILING_STOP = "LiveUtils.commitTrailingStop";
 const LIVE_METHOD_NAME_TRAILING_PROFIT = "LiveUtils.commitTrailingTake";
 const LIVE_METHOD_NAME_ACTIVATE_SCHEDULED = "Live.commitActivateScheduled";
+const LIVE_METHOD_NAME_AVERAGE_BUY = "Live.commitAverageBuy";
 /**
  * Internal task function that runs live trading and handles completion.
  * Consumes live trading results and updates instance state flags.
@@ -32259,6 +32861,49 @@ class LiveUtils {
                 frameName: "",
             }, activateId);
         };
+        /**
+         * Adds a new DCA entry to the active pending signal.
+         *
+         * Adds a new averaging entry at currentPrice to the position's entry history.
+         * Updates effectivePriceOpen (mean of all entries) and emits average-buy commit event.
+         *
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - New entry price to add to the averaging history
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise<boolean> - true if entry added, false if rejected
+         *
+         * @example
+         * ```typescript
+         * // Add DCA entry at current price
+         * const success = await Live.commitAverageBuy("BTCUSDT", 42000, {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance"
+         * });
+         * if (success) {
+         *   console.log('DCA entry added');
+         * }
+         * ```
+         */
+        this.commitAverageBuy = async (symbol, currentPrice, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_AVERAGE_BUY, {
+                symbol,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_AVERAGE_BUY);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_AVERAGE_BUY);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_AVERAGE_BUY);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_AVERAGE_BUY));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_AVERAGE_BUY));
+            }
+            return await bt.strategyCoreService.averageBuy(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
          *
@@ -34922,6 +35567,8 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            originalPriceOpen: data.signal.originalPriceOpen,
+            totalEntries: data.signal.totalEntries,
             note: data.signal.note,
             scheduledAt: data.signal.scheduledAt,
             pendingAt: data.signal.pendingAt,
@@ -34947,6 +35594,8 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            originalPriceOpen: data.signal.originalPriceOpen,
+            totalEntries: data.signal.totalEntries,
             pnlPercentage: data.pnl.pnlPercentage,
             closeReason: data.closeReason,
             duration: durationMin,
@@ -34972,6 +35621,8 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            originalPriceOpen: data.signal.originalPriceOpen,
+            totalEntries: data.signal.totalEntries,
             scheduledAt: data.signal.scheduledAt,
             currentPrice: data.currentPrice,
             createdAt: data.createdAt,
@@ -34995,6 +35646,8 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.signal.priceStopLoss,
             originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
             originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            originalPriceOpen: data.signal.originalPriceOpen,
+            totalEntries: data.signal.totalEntries,
             cancelReason: data.reason,
             cancelId: data.cancelId,
             duration: durationMin,
@@ -35027,6 +35680,8 @@ const CREATE_PARTIAL_PROFIT_NOTIFICATION_FN = (data) => ({
     priceStopLoss: data.data.priceStopLoss,
     originalPriceTakeProfit: data.data.originalPriceTakeProfit,
     originalPriceStopLoss: data.data.originalPriceStopLoss,
+    originalPriceOpen: data.data.originalPriceOpen,
+    totalEntries: data.data.totalEntries,
     scheduledAt: data.data.scheduledAt,
     pendingAt: data.data.pendingAt,
     createdAt: data.timestamp,
@@ -35053,6 +35708,8 @@ const CREATE_PARTIAL_LOSS_NOTIFICATION_FN = (data) => ({
     priceStopLoss: data.data.priceStopLoss,
     originalPriceTakeProfit: data.data.originalPriceTakeProfit,
     originalPriceStopLoss: data.data.originalPriceStopLoss,
+    originalPriceOpen: data.data.originalPriceOpen,
+    totalEntries: data.data.totalEntries,
     scheduledAt: data.data.scheduledAt,
     pendingAt: data.data.pendingAt,
     createdAt: data.timestamp,
@@ -35078,6 +35735,8 @@ const CREATE_BREAKEVEN_NOTIFICATION_FN = (data) => ({
     priceStopLoss: data.data.priceStopLoss,
     originalPriceTakeProfit: data.data.originalPriceTakeProfit,
     originalPriceStopLoss: data.data.originalPriceStopLoss,
+    originalPriceOpen: data.data.originalPriceOpen,
+    totalEntries: data.data.totalEntries,
     scheduledAt: data.data.scheduledAt,
     pendingAt: data.data.pendingAt,
     createdAt: data.timestamp,
@@ -35108,6 +35767,8 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            originalPriceOpen: data.originalPriceOpen,
+            totalEntries: data.totalEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
             createdAt: data.timestamp,
@@ -35131,6 +35792,8 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            originalPriceOpen: data.originalPriceOpen,
+            totalEntries: data.totalEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
             createdAt: data.timestamp,
@@ -35153,6 +35816,8 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            originalPriceOpen: data.originalPriceOpen,
+            totalEntries: data.totalEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
             createdAt: data.timestamp,
@@ -35176,6 +35841,8 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            originalPriceOpen: data.originalPriceOpen,
+            totalEntries: data.totalEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
             createdAt: data.timestamp,
@@ -35199,6 +35866,8 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            originalPriceOpen: data.originalPriceOpen,
+            totalEntries: data.totalEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
             createdAt: data.timestamp,
@@ -35222,6 +35891,33 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             priceStopLoss: data.priceStopLoss,
             originalPriceTakeProfit: data.originalPriceTakeProfit,
             originalPriceStopLoss: data.originalPriceStopLoss,
+            originalPriceOpen: data.originalPriceOpen,
+            totalEntries: data.totalEntries,
+            scheduledAt: data.scheduledAt,
+            pendingAt: data.pendingAt,
+            createdAt: data.timestamp,
+        };
+    }
+    if (data.action === "average-buy") {
+        return {
+            type: "average_buy.commit",
+            id: CREATE_KEY_FN$1(),
+            timestamp: data.timestamp,
+            backtest: data.backtest,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
+            exchangeName: data.exchangeName,
+            signalId: data.signalId,
+            currentPrice: data.currentPrice,
+            effectivePriceOpen: data.effectivePriceOpen,
+            totalEntries: data.totalEntries,
+            position: data.position,
+            priceOpen: data.priceOpen,
+            priceTakeProfit: data.priceTakeProfit,
+            priceStopLoss: data.priceStopLoss,
+            originalPriceTakeProfit: data.originalPriceTakeProfit,
+            originalPriceStopLoss: data.originalPriceStopLoss,
+            originalPriceOpen: data.originalPriceOpen,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
             createdAt: data.timestamp,
@@ -37564,4 +38260,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate, waitForCandle, warmCandles };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate, waitForCandle, warmCandles };