backtest-kit 1.5.1 → 1.5.3

package/build/index.mjs

@@ -1,6 +1,6 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, ToolRegistry, isObject, resolveDocuments, str, iterateDocuments, distinctDocuments, queued } from 'functools-kit';
+import { errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, ToolRegistry, isObject, and, resolveDocuments, str, iterateDocuments, distinctDocuments, queued } from 'functools-kit';
 import fs, { mkdir, writeFile } from 'fs/promises';
 import path, { join } from 'path';
 import crypto from 'crypto';
@@ -23,7 +23,13 @@ const GLOBAL_CONFIG = {
      * Must be greater than trading fees to ensure profitable trades
      * Default: 0.3% (covers 2×0.1% fees + minimum profit margin)
      */
-    CC_MIN_TAKEPROFIT_DISTANCE_PERCENT: 0.1,
+    CC_MIN_TAKEPROFIT_DISTANCE_PERCENT: 0.3,
+    /**
+     * Minimum StopLoss distance from priceOpen (percentage)
+     * Prevents signals from being immediately stopped out due to price volatility
+     * Default: 0.5% (buffer to avoid instant stop loss on normal market fluctuations)
+     */
+    CC_MIN_STOPLOSS_DISTANCE_PERCENT: 0.5,
     /**
      * Maximum StopLoss distance from priceOpen (percentage)
      * Prevents catastrophic losses from extreme StopLoss values
@@ -1667,6 +1673,8 @@ const walkerCompleteSubject = new Subject();
 /**
  * Walker stop emitter for walker cancellation events.
  * Emits when a walker comparison is stopped/cancelled.
+ *
+ * Includes walkerName to support multiple walkers running on the same symbol.
  */
 const walkerStopSubject = new Subject();
 /**
@@ -1819,18 +1827,30 @@ const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
         if (signal.priceStopLoss >= signal.priceOpen) {
             errors.push(`Long: priceStopLoss (${signal.priceStopLoss}) must be < priceOpen (${signal.priceOpen})`);
         }
-        // ЗАЩИТА ОТ EDGE CASE: для immediate сигналов проверяем что текущая цена не пробила SL/TP
-        // Для scheduled сигналов эта проверка избыточна т.к. priceOpen уже проверен выше
-        if (!isScheduled) {
-            // Текущая цена уже пробила StopLoss - позиция откроется и сразу закроется по SL
-            if (isFinite(currentPrice) && currentPrice < signal.priceStopLoss) {
-                errors.push(`Long: currentPrice (${currentPrice}) < priceStopLoss (${signal.priceStopLoss}). ` +
-                    `Signal would be immediately cancelled. This signal is invalid.`);
+        // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ: проверяем что позиция не закроется сразу после открытия
+        if (!isScheduled && isFinite(currentPrice)) {
+            // LONG: currentPrice должна быть МЕЖДУ SL и TP (не пробита ни одна граница)
+            // SL < currentPrice < TP
+            if (currentPrice <= signal.priceStopLoss) {
+                errors.push(`Long immediate: currentPrice (${currentPrice}) <= priceStopLoss (${signal.priceStopLoss}). ` +
+                    `Signal would be immediately closed by stop loss. Cannot open position that is already stopped out.`);
             }
-            // Текущая цена уже достигла TakeProfit - профит упущен
-            if (isFinite(currentPrice) && currentPrice > signal.priceTakeProfit) {
-                errors.push(`Long: currentPrice (${currentPrice}) > priceTakeProfit (${signal.priceTakeProfit}). ` +
-                    `Signal is invalid - the profit opportunity has already passed.`);
+            if (currentPrice >= signal.priceTakeProfit) {
+                errors.push(`Long immediate: currentPrice (${currentPrice}) >= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                    `Signal would be immediately closed by take profit. The profit opportunity has already passed.`);
+            }
+        }
+        // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ scheduled сигналов
+        if (isScheduled && isFinite(signal.priceOpen)) {
+            // LONG scheduled: priceOpen должен быть МЕЖДУ SL и TP
+            // SL < priceOpen < TP
+            if (signal.priceOpen <= signal.priceStopLoss) {
+                errors.push(`Long scheduled: priceOpen (${signal.priceOpen}) <= priceStopLoss (${signal.priceStopLoss}). ` +
+                    `Signal would be immediately cancelled on activation. Cannot activate position that is already stopped out.`);
+            }
+            if (signal.priceOpen >= signal.priceTakeProfit) {
+                errors.push(`Long scheduled: priceOpen (${signal.priceOpen}) >= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                    `Signal would close immediately on activation. This is logically impossible for LONG position.`);
             }
         }
         // ЗАЩИТА ОТ МИКРО-ПРОФИТА: TakeProfit должен быть достаточно далеко, чтобы покрыть комиссии
@@ -1842,8 +1862,17 @@ const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
                     `Current: TP=${signal.priceTakeProfit}, Open=${signal.priceOpen}`);
             }
         }
+        // ЗАЩИТА ОТ СЛИШКОМ УЗКОГО STOPLOSS: минимальный буфер для избежания моментального закрытия
+        if (GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT) {
+            const slDistancePercent = ((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen) * 100;
+            if (slDistancePercent < GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT) {
+                errors.push(`Long: StopLoss too close to priceOpen (${slDistancePercent.toFixed(3)}%). ` +
+                    `Minimum distance: ${GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT}% to avoid instant stop out on market volatility. ` +
+                    `Current: SL=${signal.priceStopLoss}, Open=${signal.priceOpen}`);
+            }
+        }
         // ЗАЩИТА ОТ ЭКСТРЕМАЛЬНОГО STOPLOSS: ограничиваем максимальный убыток
-        if (GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT && GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
+        if (GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
             const slDistancePercent = ((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen) * 100;
             if (slDistancePercent > GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
                 errors.push(`Long: StopLoss too far from priceOpen (${slDistancePercent.toFixed(3)}%). ` +
@@ -1860,18 +1889,30 @@ const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
         if (signal.priceStopLoss <= signal.priceOpen) {
             errors.push(`Short: priceStopLoss (${signal.priceStopLoss}) must be > priceOpen (${signal.priceOpen})`);
         }
-        // ЗАЩИТА ОТ EDGE CASE: для immediate сигналов проверяем что текущая цена не пробила SL/TP
-        // Для scheduled сигналов эта проверка избыточна т.к. priceOpen уже проверен выше
-        if (!isScheduled) {
-            // Текущая цена уже пробила StopLoss - позиция откроется и сразу закроется по SL
-            if (isFinite(currentPrice) && currentPrice > signal.priceStopLoss) {
-                errors.push(`Short: currentPrice (${currentPrice}) > priceStopLoss (${signal.priceStopLoss}). ` +
-                    `Signal would be immediately cancelled. This signal is invalid.`);
+        // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ: проверяем что позиция не закроется сразу после открытия
+        if (!isScheduled && isFinite(currentPrice)) {
+            // SHORT: currentPrice должна быть МЕЖДУ TP и SL (не пробита ни одна граница)
+            // TP < currentPrice < SL
+            if (currentPrice >= signal.priceStopLoss) {
+                errors.push(`Short immediate: currentPrice (${currentPrice}) >= priceStopLoss (${signal.priceStopLoss}). ` +
+                    `Signal would be immediately closed by stop loss. Cannot open position that is already stopped out.`);
+            }
+            if (currentPrice <= signal.priceTakeProfit) {
+                errors.push(`Short immediate: currentPrice (${currentPrice}) <= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                    `Signal would be immediately closed by take profit. The profit opportunity has already passed.`);
+            }
+        }
+        // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ scheduled сигналов
+        if (isScheduled && isFinite(signal.priceOpen)) {
+            // SHORT scheduled: priceOpen должен быть МЕЖДУ TP и SL
+            // TP < priceOpen < SL
+            if (signal.priceOpen >= signal.priceStopLoss) {
+                errors.push(`Short scheduled: priceOpen (${signal.priceOpen}) >= priceStopLoss (${signal.priceStopLoss}). ` +
+                    `Signal would be immediately cancelled on activation. Cannot activate position that is already stopped out.`);
             }
-            // Текущая цена уже достигла TakeProfit - профит упущен
-            if (isFinite(currentPrice) && currentPrice < signal.priceTakeProfit) {
-                errors.push(`Short: currentPrice (${currentPrice}) < priceTakeProfit (${signal.priceTakeProfit}). ` +
-                    `Signal is invalid - the profit opportunity has already passed.`);
+            if (signal.priceOpen <= signal.priceTakeProfit) {
+                errors.push(`Short scheduled: priceOpen (${signal.priceOpen}) <= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                    `Signal would close immediately on activation. This is logically impossible for SHORT position.`);
             }
         }
         // ЗАЩИТА ОТ МИКРО-ПРОФИТА: TakeProfit должен быть достаточно далеко, чтобы покрыть комиссии
@@ -1883,8 +1924,17 @@ const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
                     `Current: TP=${signal.priceTakeProfit}, Open=${signal.priceOpen}`);
             }
         }
+        // ЗАЩИТА ОТ СЛИШКОМ УЗКОГО STOPLOSS: минимальный буфер для избежания моментального закрытия
+        if (GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT) {
+            const slDistancePercent = ((signal.priceStopLoss - signal.priceOpen) / signal.priceOpen) * 100;
+            if (slDistancePercent < GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT) {
+                errors.push(`Short: StopLoss too close to priceOpen (${slDistancePercent.toFixed(3)}%). ` +
+                    `Minimum distance: ${GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT}% to avoid instant stop out on market volatility. ` +
+                    `Current: SL=${signal.priceStopLoss}, Open=${signal.priceOpen}`);
+            }
+        }
         // ЗАЩИТА ОТ ЭКСТРЕМАЛЬНОГО STOPLOSS: ограничиваем максимальный убыток
-        if (GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT && GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
+        if (GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
             const slDistancePercent = ((signal.priceStopLoss - signal.priceOpen) / signal.priceOpen) * 100;
             if (slDistancePercent > GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
                 errors.push(`Short: StopLoss too far from priceOpen (${slDistancePercent.toFixed(3)}%). ` +
@@ -2575,8 +2625,14 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
 const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) => {
     const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
     const maxTimeToWait = GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES * 60 * 1000;
+    const bufferCandlesCount = candlesCount - 1;
     for (let i = 0; i < candles.length; i++) {
         const candle = candles[i];
+        // КРИТИЧНО: Пропускаем первые bufferCandlesCount свечей (буфер для VWAP)
+        // BacktestLogicPrivateService запросил свечи начиная с (when - bufferMinutes)
+        if (i < bufferCandlesCount) {
+            continue;
+        }
         const recentCandles = candles.slice(Math.max(0, i - (candlesCount - 1)), i + 1);
         const averagePrice = GET_AVG_PRICE_FN(recentCandles);
         // КРИТИЧНО: Проверяем timeout ПЕРЕД проверкой цены
@@ -2642,11 +2698,21 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
 };
 const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
     const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
-    for (let i = candlesCount - 1; i < candles.length; i++) {
-        const recentCandles = candles.slice(i - (candlesCount - 1), i + 1);
+    const bufferCandlesCount = candlesCount - 1;
+    // КРИТИЧНО: проверяем TP/SL на КАЖДОЙ свече начиная после буфера
+    // Первые bufferCandlesCount свечей - это буфер для VWAP
+    for (let i = 0; i < candles.length; i++) {
+        const currentCandle = candles[i];
+        const currentCandleTimestamp = currentCandle.timestamp;
+        // КРИТИЧНО: Пропускаем первые bufferCandlesCount свечей (буфер для VWAP)
+        // BacktestLogicPrivateService запросил свечи начиная с (when - bufferMinutes)
+        if (i < bufferCandlesCount) {
+            continue;
+        }
+        // Берем последние candlesCount свечей для VWAP (включая буфер)
+        const startIndex = Math.max(0, i - (candlesCount - 1));
+        const recentCandles = candles.slice(startIndex, i + 1);
         const averagePrice = GET_AVG_PRICE_FN(recentCandles);
-        const currentCandleTimestamp = recentCandles[recentCandles.length - 1].timestamp;
-        const currentCandle = recentCandles[recentCandles.length - 1];
         let shouldClose = false;
         let closeReason;
         // Check time expiration FIRST (КРИТИЧНО!)
@@ -2843,6 +2909,23 @@ class ClientStrategy {
         });
         return this._pendingSignal;
     }
+    /**
+     * Returns the stopped state of the strategy.
+     *
+     * Indicates whether the strategy has been explicitly stopped and should
+     * not continue processing new ticks or signals.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Name of the strategy
+     * @returns Promise resolving to true if strategy is stopped, false otherwise
+     */
+    async getStopped(symbol, strategyName) {
+        this.params.logger.debug("ClientStrategy getStopped", {
+            symbol,
+            strategyName,
+        });
+        return this._isStopped;
+    }
     /**
      * Performs a single tick of strategy execution.
      *
@@ -2946,9 +3029,10 @@ class ClientStrategy {
      * 4. If cancelled: returns closed result with closeReason "cancelled"
      *
      * For pending signals:
-     * 1. Iterates through candles checking VWAP against TP/SL on each timeframe
-     * 2. Starts from index 4 (needs 5 candles for VWAP calculation)
-     * 3. Returns closed result (either TP/SL or time_expired)
+     * 1. Iterates through ALL candles starting from the first one
+     * 2. Checks TP/SL using candle.high/low (immediate detection)
+     * 3. VWAP calculated with dynamic window (1 to CC_AVG_PRICE_CANDLES_COUNT candles)
+     * 4. Returns closed result (either TP/SL or time_expired)
      *
      * @param candles - Array of candles to process
      * @returns Promise resolving to closed signal result with PNL
@@ -3084,18 +3168,24 @@ class ClientStrategy {
      * // Existing signal will continue until natural close
      * ```
      */
-    async stop(symbol, strategyName) {
+    async stop(symbol, strategyName, backtest) {
         this.params.logger.debug("ClientStrategy stop", {
             symbol,
             strategyName,
             hasPendingSignal: this._pendingSignal !== null,
             hasScheduledSignal: this._scheduledSignal !== null,
+            backtest,
         });
         this._isStopped = true;
         // Clear scheduled signal if exists
-        if (this._scheduledSignal) {
-            await this.setScheduledSignal(null);
+        if (!this._scheduledSignal) {
+            return;
         }
+        this._scheduledSignal = null;
+        if (backtest) {
+            return;
+        }
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, this.params.execution.context.symbol, this.params.strategyName);
     }
 }
 
@@ -3178,6 +3268,24 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, strategyName);
             return await strategy.getPendingSignal(symbol, strategyName);
         };
+        /**
+         * Retrieves the stopped state of the strategy.
+         *
+         * Delegates to the underlying strategy instance to check if it has been
+         * marked as stopped and should cease operation.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of the strategy
+         * @returns Promise resolving to true if strategy is stopped, false otherwise
+         */
+        this.getStopped = async (symbol, strategyName) => {
+            this.loggerService.log("strategyConnectionService getStopped", {
+                symbol,
+                strategyName,
+            });
+            const strategy = this.getStrategy(symbol, strategyName);
+            return await strategy.getStopped(symbol, strategyName);
+        };
         /**
          * Executes live trading tick for current strategy.
          *
@@ -3245,12 +3353,12 @@ class StrategyConnectionService {
          * @param strategyName - Name of strategy to stop
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (ctx) => {
+        this.stop = async (ctx, backtest) => {
             this.loggerService.log("strategyConnectionService stop", {
                 ctx
             });
             const strategy = this.getStrategy(ctx.symbol, ctx.strategyName);
-            await strategy.stop(ctx.symbol, ctx.strategyName);
+            await strategy.stop(ctx.symbol, ctx.strategyName, backtest);
         };
         /**
          * Clears the memoized ClientStrategy instance from cache.
@@ -4115,6 +4223,24 @@ class StrategyGlobalService {
             await this.validate(symbol, strategyName);
             return await this.strategyConnectionService.getPendingSignal(symbol, strategyName);
         };
+        /**
+         * Checks if the strategy has been stopped.
+         *
+         * Validates strategy existence and delegates to connection service
+         * to retrieve the stopped state from the strategy instance.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of the strategy
+         * @returns Promise resolving to true if strategy is stopped, false otherwise
+         */
+        this.getStopped = async (symbol, strategyName) => {
+            this.loggerService.log("strategyGlobalService getStopped", {
+                symbol,
+                strategyName,
+            });
+            await this.validate(symbol, strategyName);
+            return await this.strategyConnectionService.getStopped(symbol, strategyName);
+        };
         /**
          * Checks signal status at a specific timestamp.
          *
@@ -4181,12 +4307,13 @@ class StrategyGlobalService {
          * @param strategyName - Name of strategy to stop
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (ctx) => {
+        this.stop = async (ctx, backtest) => {
             this.loggerService.log("strategyGlobalService stop", {
                 ctx,
+                backtest,
             });
             await this.validate(ctx.symbol, ctx.strategyName);
-            return await this.strategyConnectionService.stop(ctx);
+            return await this.strategyConnectionService.stop(ctx, backtest);
         };
         /**
          * Clears the memoized ClientStrategy instance from cache.
@@ -4878,6 +5005,16 @@ class BacktestLogicPrivateService {
                     progress: totalFrames > 0 ? i / totalFrames : 0,
                 });
             }
+            // Check if strategy should stop before processing next frame
+            if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                this.loggerService.info("backtestLogicPrivateService stopped by user request (before tick)", {
+                    symbol,
+                    when: when.toISOString(),
+                    processedFrames: i,
+                    totalFrames,
+                });
+                break;
+            }
             let result;
             try {
                 result = await this.strategyGlobalService.tick(symbol, when, true);
@@ -4893,6 +5030,16 @@ class BacktestLogicPrivateService {
                 i++;
                 continue;
             }
+            // Check if strategy should stop when idle (no active signal)
+            if (await and(Promise.resolve(result.action === "idle"), this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+                this.loggerService.info("backtestLogicPrivateService stopped by user request (idle state)", {
+                    symbol,
+                    when: when.toISOString(),
+                    processedFrames: i,
+                    totalFrames,
+                });
+                break;
+            }
             // Если scheduled signal создан - обрабатываем через backtest()
             if (result.action === "scheduled") {
                 const signalStartTime = performance.now();
@@ -4904,13 +5051,17 @@ class BacktestLogicPrivateService {
                     minuteEstimatedTime: signal.minuteEstimatedTime,
                 });
                 // Запрашиваем минутные свечи для мониторинга активации/отмены
-                // КРИТИЧНО: запрашиваем CC_SCHEDULE_AWAIT_MINUTES для ожидания активации
-                // + minuteEstimatedTime для работы сигнала ПОСЛЕ активации
-                // +1 потому что when включается как первая свеча (timestamp начинается с when, а не after when)
-                const candlesNeeded = GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES + signal.minuteEstimatedTime + 1;
+                // КРИТИЧНО: запрашиваем:
+                // - CC_AVG_PRICE_CANDLES_COUNT-1 для буфера VWAP (ДО when)
+                // - CC_SCHEDULE_AWAIT_MINUTES для ожидания активации
+                // - minuteEstimatedTime для работы сигнала ПОСЛЕ активации
+                // - +1 потому что when включается как первая свеча
+                const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
+                const bufferStartTime = new Date(when.getTime() - bufferMinutes * 60 * 1000);
+                const candlesNeeded = bufferMinutes + GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES + signal.minuteEstimatedTime + 1;
                 let candles;
                 try {
-                    candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", candlesNeeded, when, true);
+                    candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", candlesNeeded, bufferStartTime, true);
                 }
                 catch (error) {
                     console.warn(`backtestLogicPrivateService getNextCandles failed for scheduled signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
@@ -4918,6 +5069,7 @@ class BacktestLogicPrivateService {
                         symbol,
                         signalId: signal.id,
                         candlesNeeded,
+                        bufferMinutes,
                         error: errorData(error), message: getErrorMessage(error),
                     });
                     await errorEmitter.next(error);
@@ -4980,6 +5132,16 @@ class BacktestLogicPrivateService {
                     i++;
                 }
                 yield backtestResult;
+                // Check if strategy should stop after signal is closed
+                if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                    this.loggerService.info("backtestLogicPrivateService stopped by user request (after scheduled signal closed)", {
+                        symbol,
+                        signalId: backtestResult.signal.id,
+                        processedFrames: i,
+                        totalFrames,
+                    });
+                    break;
+                }
             }
             // Если обычный сигнал открыт, вызываем backtest
             if (result.action === "opened") {
@@ -4990,16 +5152,23 @@ class BacktestLogicPrivateService {
                     signalId: signal.id,
                     minuteEstimatedTime: signal.minuteEstimatedTime,
                 });
-                // Получаем свечи для бектеста
+                // КРИТИЧНО: Получаем свечи включая буфер для VWAP
+                // Сдвигаем начало назад на CC_AVG_PRICE_CANDLES_COUNT-1 минут для буфера VWAP
+                // Запрашиваем minuteEstimatedTime + буфер свечей одним запросом
+                const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
+                const bufferStartTime = new Date(when.getTime() - bufferMinutes * 60 * 1000);
+                const totalCandles = signal.minuteEstimatedTime + bufferMinutes;
                 let candles;
                 try {
-                    candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", signal.minuteEstimatedTime, when, true);
+                    candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", totalCandles, bufferStartTime, true);
                 }
                 catch (error) {
                     console.warn(`backtestLogicPrivateService getNextCandles failed for opened signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
                     this.loggerService.warn("backtestLogicPrivateService getNextCandles failed for opened signal", {
                         symbol,
                         signalId: signal.id,
+                        totalCandles,
+                        bufferMinutes,
                         error: errorData(error), message: getErrorMessage(error),
                     });
                     await errorEmitter.next(error);
@@ -5056,6 +5225,16 @@ class BacktestLogicPrivateService {
                     i++;
                 }
                 yield backtestResult;
+                // Check if strategy should stop after signal is closed
+                if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                    this.loggerService.info("backtestLogicPrivateService stopped by user request (after signal closed)", {
+                        symbol,
+                        signalId: backtestResult.signal.id,
+                        processedFrames: i,
+                        totalFrames,
+                    });
+                    break;
+                }
             }
             // Track timeframe processing duration
             const timeframeEndTime = performance.now();
@@ -5163,7 +5342,8 @@ class LiveLogicPrivateService {
                 this.loggerService.warn("liveLogicPrivateService tick failed, retrying after sleep", {
                     symbol,
                     when: when.toISOString(),
-                    error: errorData(error), message: getErrorMessage(error),
+                    error: errorData(error),
+                    message: getErrorMessage(error),
                 });
                 await errorEmitter.next(error);
                 await sleep(TICK_TTL);
@@ -5187,11 +5367,19 @@ class LiveLogicPrivateService {
                 backtest: false,
             });
             previousEventTimestamp = currentTimestamp;
-            if (result.action === "active") {
+            // Check if strategy should stop when idle (no active signal)
+            if (result.action === "idle") {
+                if (await and(Promise.resolve(true), this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+                    this.loggerService.info("liveLogicPrivateService stopped by user request (idle state)", {
+                        symbol,
+                        when: when.toISOString(),
+                    });
+                    break;
+                }
                 await sleep(TICK_TTL);
                 continue;
             }
-            if (result.action === "idle") {
+            if (result.action === "active") {
                 await sleep(TICK_TTL);
                 continue;
             }
@@ -5201,12 +5389,21 @@ class LiveLogicPrivateService {
             }
             // Yield opened, closed results
             yield result;
+            // Check if strategy should stop after signal is closed
+            if (result.action === "closed") {
+                if (await this.strategyGlobalService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                    this.loggerService.info("liveLogicPrivateService stopped by user request (after signal closed)", {
+                        symbol,
+                        signalId: result.signal.id,
+                    });
+                    break;
+                }
+            }
             await sleep(TICK_TTL);
         }
     }
 }
 
-const CANCEL_SYMBOL = Symbol("CANCEL_SYMBOL");
 /**
  * Private service for walker orchestration (strategy comparison).
  *
@@ -5264,112 +5461,121 @@ class WalkerLogicPrivateService {
         let strategiesTested = 0;
         let bestMetric = null;
         let bestStrategy = null;
-        let pendingStrategy;
-        const listenStop = walkerStopSubject
-            .filter((data) => {
-            let isOk = true;
-            isOk = isOk && data.symbol === symbol;
-            isOk = isOk && data.strategyName === pendingStrategy;
-            return isOk;
-        })
-            .map(() => CANCEL_SYMBOL)
-            .toPromise();
-        // Run backtest for each strategy
-        for (const strategyName of strategies) {
-            // Call onStrategyStart callback if provided
-            if (walkerSchema.callbacks?.onStrategyStart) {
-                walkerSchema.callbacks.onStrategyStart(strategyName, symbol);
-            }
-            this.loggerService.info("walkerLogicPrivateService testing strategy", {
-                strategyName,
+        // Track stopped strategies in Set for efficient lookup
+        const stoppedStrategies = new Set();
+        // Subscribe to stop signals and collect them in Set
+        // Filter by both symbol AND walkerName to support multiple walkers on same symbol
+        // connect() returns destructor function
+        const unsubscribe = walkerStopSubject
+            .filter((data) => data.symbol === symbol && data.walkerName === context.walkerName)
+            .connect((data) => {
+            stoppedStrategies.add(data.strategyName);
+            this.loggerService.info("walkerLogicPrivateService received stop signal for strategy", {
                 symbol,
+                walkerName: context.walkerName,
+                strategyName: data.strategyName,
+                stoppedCount: stoppedStrategies.size,
             });
-            const iterator = this.backtestLogicPublicService.run(symbol, {
-                strategyName,
-                exchangeName: context.exchangeName,
-                frameName: context.frameName,
-            });
-            pendingStrategy = strategyName;
-            let result;
-            try {
-                result = await Promise.race([
-                    await resolveDocuments(iterator),
-                    listenStop,
-                ]);
-            }
-            catch (error) {
-                console.warn(`walkerLogicPrivateService backtest failed symbol=${symbol} strategyName=${strategyName} exchangeName=${context.exchangeName}`);
-                this.loggerService.warn("walkerLogicPrivateService backtest failed for strategy, skipping", {
+        });
+        try {
+            // Run backtest for each strategy
+            for (const strategyName of strategies) {
+                // Check if this strategy should be stopped before starting
+                if (stoppedStrategies.has(strategyName)) {
+                    this.loggerService.info("walkerLogicPrivateService skipping stopped strategy", {
+                        symbol,
+                        strategyName,
+                    });
+                    break;
+                }
+                // Call onStrategyStart callback if provided
+                if (walkerSchema.callbacks?.onStrategyStart) {
+                    walkerSchema.callbacks.onStrategyStart(strategyName, symbol);
+                }
+                this.loggerService.info("walkerLogicPrivateService testing strategy", {
                     strategyName,
                     symbol,
-                    error: errorData(error), message: getErrorMessage(error),
                 });
-                await errorEmitter.next(error);
-                // Call onStrategyError callback if provided
-                if (walkerSchema.callbacks?.onStrategyError) {
-                    walkerSchema.callbacks.onStrategyError(strategyName, symbol, error);
+                const iterator = this.backtestLogicPublicService.run(symbol, {
+                    strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                });
+                try {
+                    await resolveDocuments(iterator);
                 }
-                continue;
-            }
-            if (result === CANCEL_SYMBOL) {
-                this.loggerService.info("walkerLogicPrivateService received stop signal, cancelling walker", {
-                    context,
+                catch (error) {
+                    console.warn(`walkerLogicPrivateService backtest failed symbol=${symbol} strategyName=${strategyName} exchangeName=${context.exchangeName}`);
+                    this.loggerService.warn("walkerLogicPrivateService backtest failed for strategy, skipping", {
+                        strategyName,
+                        symbol,
+                        error: errorData(error), message: getErrorMessage(error),
+                    });
+                    await errorEmitter.next(error);
+                    // Call onStrategyError callback if provided
+                    if (walkerSchema.callbacks?.onStrategyError) {
+                        walkerSchema.callbacks.onStrategyError(strategyName, symbol, error);
+                    }
+                    continue;
+                }
+                this.loggerService.info("walkerLogicPrivateService backtest complete", {
+                    strategyName,
+                    symbol,
                 });
-                break;
-            }
-            this.loggerService.info("walkerLogicPrivateService backtest complete", {
-                strategyName,
-                symbol,
-            });
-            // Get statistics from BacktestMarkdownService
-            const stats = await this.backtestMarkdownService.getData(symbol, strategyName);
-            // Extract metric value
-            const value = stats[metric];
-            const metricValue = value !== null &&
-                value !== undefined &&
-                typeof value === "number" &&
-                !isNaN(value) &&
-                isFinite(value)
-                ? value
-                : null;
-            // Update best strategy if needed
-            const isBetter = bestMetric === null ||
-                (metricValue !== null && metricValue > bestMetric);
-            if (isBetter && metricValue !== null) {
-                bestMetric = metricValue;
-                bestStrategy = strategyName;
-            }
-            strategiesTested++;
-            const walkerContract = {
-                walkerName: context.walkerName,
-                exchangeName: context.exchangeName,
-                frameName: context.frameName,
-                symbol,
-                strategyName,
-                stats,
-                metricValue,
-                metric,
-                bestMetric,
-                bestStrategy,
-                strategiesTested,
-                totalStrategies: strategies.length,
-            };
-            // Emit progress event
-            await progressWalkerEmitter.next({
-                walkerName: context.walkerName,
-                exchangeName: context.exchangeName,
-                frameName: context.frameName,
-                symbol,
-                totalStrategies: strategies.length,
-                processedStrategies: strategiesTested,
-                progress: strategies.length > 0 ? strategiesTested / strategies.length : 0,
-            });
-            // Call onStrategyComplete callback if provided
-            if (walkerSchema.callbacks?.onStrategyComplete) {
-                walkerSchema.callbacks.onStrategyComplete(strategyName, symbol, stats, metricValue);
+                // Get statistics from BacktestMarkdownService
+                const stats = await this.backtestMarkdownService.getData(symbol, strategyName);
+                // Extract metric value
+                const value = stats[metric];
+                const metricValue = value !== null &&
+                    value !== undefined &&
+                    typeof value === "number" &&
+                    !isNaN(value) &&
+                    isFinite(value)
+                    ? value
+                    : null;
+                // Update best strategy if needed
+                const isBetter = bestMetric === null ||
+                    (metricValue !== null && metricValue > bestMetric);
+                if (isBetter && metricValue !== null) {
+                    bestMetric = metricValue;
+                    bestStrategy = strategyName;
+                }
+                strategiesTested++;
+                const walkerContract = {
+                    walkerName: context.walkerName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    symbol,
+                    strategyName,
+                    stats,
+                    metricValue,
+                    metric,
+                    bestMetric,
+                    bestStrategy,
+                    strategiesTested,
+                    totalStrategies: strategies.length,
+                };
+                // Emit progress event
+                await progressWalkerEmitter.next({
+                    walkerName: context.walkerName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    symbol,
+                    totalStrategies: strategies.length,
+                    processedStrategies: strategiesTested,
+                    progress: strategies.length > 0 ? strategiesTested / strategies.length : 0,
+                });
+                // Call onStrategyComplete callback if provided
+                if (walkerSchema.callbacks?.onStrategyComplete) {
+                    await walkerSchema.callbacks.onStrategyComplete(strategyName, symbol, stats, metricValue);
+                }
+                await walkerEmitter.next(walkerContract);
+                yield walkerContract;
             }
-            await walkerEmitter.next(walkerContract);
-            yield walkerContract;
+        }
+        finally {
+            // Unsubscribe from stop signals by calling destructor
+            unsubscribe();
         }
         const finalResults = {
             walkerName: context.walkerName,
@@ -13191,6 +13397,7 @@ async function dumpSignal(signalId, history, signal, outputDir = "./dump/strateg
 
 const BACKTEST_METHOD_NAME_RUN = "BacktestUtils.run";
 const BACKTEST_METHOD_NAME_BACKGROUND = "BacktestUtils.background";
+const BACKTEST_METHOD_NAME_STOP = "BacktestUtils.stop";
 const BACKTEST_METHOD_NAME_GET_REPORT = "BacktestUtils.getReport";
 const BACKTEST_METHOD_NAME_DUMP = "BacktestUtils.dump";
 /**
@@ -13285,7 +13492,7 @@ class BacktestUtils {
             };
             task().catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
-                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName });
+                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName }, true);
                 backtest$1.strategyGlobalService
                     .getPendingSignal(symbol, context.strategyName)
                     .then(async (pendingSignal) => {
@@ -13305,6 +13512,30 @@ class BacktestUtils {
                 isStopped = true;
             };
         };
+        /**
+         * Stops the strategy from generating new signals.
+         *
+         * Sets internal flag to prevent strategy from opening new signals.
+         * Current active signal (if any) will complete normally.
+         * Backtest will stop at the next safe point (idle state or after signal closes).
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to stop
+         * @returns Promise that resolves when stop flag is set
+         *
+         * @example
+         * ```typescript
+         * // Stop strategy after some condition
+         * await Backtest.stop("BTCUSDT", "my-strategy");
+         * ```
+         */
+        this.stop = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_STOP, {
+                symbol,
+                strategyName,
+            });
+            await backtest$1.strategyGlobalService.stop({ symbol, strategyName }, true);
+        };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
          *
@@ -13393,6 +13624,7 @@ const Backtest = new BacktestUtils();
 
 const LIVE_METHOD_NAME_RUN = "LiveUtils.run";
 const LIVE_METHOD_NAME_BACKGROUND = "LiveUtils.background";
+const LIVE_METHOD_NAME_STOP = "LiveUtils.stop";
 const LIVE_METHOD_NAME_GET_REPORT = "LiveUtils.getReport";
 const LIVE_METHOD_NAME_DUMP = "LiveUtils.dump";
 /**
@@ -13500,7 +13732,7 @@ class LiveUtils {
             };
             task().catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
-                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName });
+                backtest$1.strategyGlobalService.stop({ symbol, strategyName: context.strategyName }, false);
                 backtest$1.strategyGlobalService
                     .getPendingSignal(symbol, context.strategyName)
                     .then(async (pendingSignal) => {
@@ -13520,6 +13752,30 @@ class LiveUtils {
                 isStopped = true;
             };
         };
+        /**
+         * Stops the strategy from generating new signals.
+         *
+         * Sets internal flag to prevent strategy from opening new signals.
+         * Current active signal (if any) will complete normally.
+         * Live trading will stop at the next safe point (idle/closed state).
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy name to stop
+         * @returns Promise that resolves when stop flag is set
+         *
+         * @example
+         * ```typescript
+         * // Stop live trading gracefully
+         * await Live.stop("BTCUSDT", "my-strategy");
+         * ```
+         */
+        this.stop = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_STOP, {
+                symbol,
+                strategyName,
+            });
+            await backtest$1.strategyGlobalService.stop({ symbol, strategyName }, false);
+        };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
          *
@@ -13827,6 +14083,7 @@ class Performance {
 
 const WALKER_METHOD_NAME_RUN = "WalkerUtils.run";
 const WALKER_METHOD_NAME_BACKGROUND = "WalkerUtils.background";
+const WALKER_METHOD_NAME_STOP = "WalkerUtils.stop";
 const WALKER_METHOD_NAME_GET_DATA = "WalkerUtils.getData";
 const WALKER_METHOD_NAME_GET_REPORT = "WalkerUtils.getReport";
 const WALKER_METHOD_NAME_DUMP = "WalkerUtils.dump";
@@ -13937,8 +14194,8 @@ class WalkerUtils {
             task().catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
-                    backtest$1.strategyGlobalService.stop({ symbol, strategyName });
-                    walkerStopSubject.next({ symbol, strategyName });
+                    backtest$1.strategyGlobalService.stop({ symbol, strategyName }, true);
+                    walkerStopSubject.next({ symbol, strategyName, walkerName: context.walkerName });
                 }
                 if (!isDone) {
                     doneWalkerSubject.next({
@@ -13952,6 +14209,40 @@ class WalkerUtils {
                 isStopped = true;
             };
         };
+        /**
+         * Stops all strategies in the walker from generating new signals.
+         *
+         * Iterates through all strategies defined in walker schema and:
+         * 1. Sends stop signal via walkerStopSubject (interrupts current running strategy)
+         * 2. Sets internal stop flag for each strategy (prevents new signals)
+         *
+         * Current active signals (if any) will complete normally.
+         * Walker will stop at the next safe point.
+         *
+         * Supports multiple walkers running on the same symbol simultaneously.
+         * Stop signal is filtered by walkerName to prevent interference.
+         *
+         * @param symbol - Trading pair symbol
+         * @param walkerName - Walker name to stop
+         * @returns Promise that resolves when all stop flags are set
+         *
+         * @example
+         * ```typescript
+         * // Stop walker and all its strategies
+         * await Walker.stop("BTCUSDT", "my-walker");
+         * ```
+         */
+        this.stop = async (symbol, walkerName) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_STOP, {
+                symbol,
+                walkerName,
+            });
+            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+            for (const strategyName of walkerSchema.strategies) {
+                await walkerStopSubject.next({ symbol, strategyName, walkerName });
+                await backtest$1.strategyGlobalService.stop({ symbol, strategyName }, true);
+            }
+        };
         /**
          * Gets walker results data from all strategy comparisons.
          *