backtest-kit 2.3.2 → 2.3.3

package/build/index.cjs

@@ -5024,6 +5024,68 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
             const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "user");
             return { activated: false, cancelled: true, activationIndex: i, result };
         }
+        // КРИТИЧНО: Проверяем был ли сигнал активирован пользователем через activateScheduled()
+        // Обрабатываем inline (как в tick()) с риск-проверкой по averagePrice
+        if (self._activatedSignal) {
+            const activatedSignal = self._activatedSignal;
+            self._activatedSignal = null;
+            // Check if strategy was stopped
+            if (self._isStopped) {
+                self.params.logger.info("ClientStrategy backtest user-activated signal cancelled (stopped)", {
+                    symbol: self.params.execution.context.symbol,
+                    signalId: activatedSignal.id,
+                });
+                await self.setScheduledSignal(null);
+                return { activated: false, cancelled: false, activationIndex: i, result: null };
+            }
+            // Риск-проверка по averagePrice (симметрия с LIVE tick())
+            if (await functoolsKit.not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, activatedSignal, averagePrice, candle.timestamp, self.params.execution.context.backtest))) {
+                self.params.logger.info("ClientStrategy backtest user-activated signal rejected by risk", {
+                    symbol: self.params.execution.context.symbol,
+                    signalId: activatedSignal.id,
+                });
+                await self.setScheduledSignal(null);
+                return { activated: false, cancelled: false, activationIndex: i, result: null };
+            }
+            await self.setScheduledSignal(null);
+            const pendingSignal = {
+                ...activatedSignal,
+                pendingAt: candle.timestamp,
+                _isScheduled: false,
+            };
+            await self.setPendingSignal(pendingSignal);
+            await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, pendingSignal, candle.timestamp, self.params.execution.context.backtest);
+            // Emit commit AFTER successful risk check
+            const publicSignalForCommit = TO_PUBLIC_SIGNAL(pendingSignal);
+            await CALL_COMMIT_FN(self, {
+                action: "activate-scheduled",
+                symbol: self.params.execution.context.symbol,
+                strategyName: self.params.strategyName,
+                exchangeName: self.params.exchangeName,
+                frameName: self.params.frameName,
+                signalId: activatedSignal.id,
+                backtest: self.params.execution.context.backtest,
+                activateId: activatedSignal.activateId,
+                timestamp: candle.timestamp,
+                currentPrice: averagePrice,
+                position: publicSignalForCommit.position,
+                priceOpen: publicSignalForCommit.priceOpen,
+                priceTakeProfit: publicSignalForCommit.priceTakeProfit,
+                priceStopLoss: publicSignalForCommit.priceStopLoss,
+                originalPriceTakeProfit: publicSignalForCommit.originalPriceTakeProfit,
+                originalPriceStopLoss: publicSignalForCommit.originalPriceStopLoss,
+                scheduledAt: publicSignalForCommit.scheduledAt,
+                pendingAt: publicSignalForCommit.pendingAt,
+            });
+            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);
+            return {
+                activated: true,
+                cancelled: false,
+                activationIndex: i,
+                result: null,
+            };
+        }
         // КРИТИЧНО: Проверяем timeout ПЕРЕД проверкой цены
         const elapsedTime = candle.timestamp - scheduled.scheduledAt;
         if (elapsedTime >= maxTimeToWait) {
@@ -5246,6 +5308,7 @@ class ClientStrategy {
         this._scheduledSignal = null;
         this._cancelledSignal = null;
         this._closedSignal = null;
+        this._activatedSignal = null;
         /** Queue for commit events to be processed in tick()/backtest() with proper timestamp */
         this._commitQueue = [];
         /**
@@ -5283,6 +5346,16 @@ class ClientStrategy {
         this.params.logger.debug("ClientStrategy setPendingSignal", {
             pendingSignal,
         });
+        // КРИТИЧНО: Очищаем флаг закрытия при любом изменении pending signal
+        // - при null: сигнал закрыт по TP/SL/timeout, флаг больше не нужен
+        // - при новом сигнале: флаг от предыдущего сигнала не должен влиять на новый
+        this._closedSignal = null;
+        // ЗАЩИТА ИНВАРИАНТА: При установке нового pending сигнала очищаем scheduled
+        // Не может быть одновременно pending И scheduled (взаимоисключающие состояния)
+        // При null: scheduled может существовать (новый сигнал после закрытия позиции)
+        if (pendingSignal !== null) {
+            this._scheduledSignal = null;
+        }
         this._pendingSignal = pendingSignal;
         // КРИТИЧНО: Всегда вызываем коллбек onWrite для тестирования persist storage
         // даже в backtest режиме, чтобы тесты могли перехватывать вызовы через mock adapter
@@ -5308,6 +5381,11 @@ class ClientStrategy {
         this.params.logger.debug("ClientStrategy setScheduledSignal", {
             scheduledSignal,
         });
+        // КРИТИЧНО: Очищаем флаги отмены и активации при любом изменении scheduled signal
+        // - при null: сигнал отменен/активирован по timeout/SL/user, флаги больше не нужны
+        // - при новом сигнале: флаги от предыдущего сигнала не должны влиять на новый
+        this._cancelledSignal = null;
+        this._activatedSignal = null;
         this._scheduledSignal = scheduledSignal;
         if (this.params.execution.context.backtest) {
             return;
@@ -5497,12 +5575,8 @@ class ClientStrategy {
         const currentTime = this.params.execution.context.when.getTime();
         // Process queued commit events with proper timestamp
         await PROCESS_COMMIT_QUEUE_FN(this, currentTime);
-        // Early return if strategy was stopped
-        if (this._isStopped) {
-            const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
-            return await RETURN_IDLE_FN(this, currentPrice);
-        }
         // Check if scheduled signal was cancelled - emit cancelled event once
+        // NOTE: No _isStopped check here - cancellation must work for graceful shutdown
         if (this._cancelledSignal) {
             const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
             const cancelledSignal = this._cancelledSignal;
@@ -5511,6 +5585,18 @@ class ClientStrategy {
                 symbol: this.params.execution.context.symbol,
                 signalId: cancelledSignal.id,
             });
+            // Emit commit with correct timestamp from tick context
+            await CALL_COMMIT_FN(this, {
+                action: "cancel-scheduled",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: cancelledSignal.id,
+                backtest: this.params.execution.context.backtest,
+                cancelId: cancelledSignal.cancelId,
+                timestamp: currentTime,
+            });
             // Call onCancel callback
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, currentTime, this.params.execution.context.backtest);
             const result = {
@@ -5539,6 +5625,18 @@ class ClientStrategy {
                 symbol: this.params.execution.context.symbol,
                 signalId: closedSignal.id,
             });
+            // Emit commit with correct timestamp from tick context
+            await CALL_COMMIT_FN(this, {
+                action: "close-pending",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: closedSignal.id,
+                backtest: this.params.execution.context.backtest,
+                closeId: closedSignal.closeId,
+                timestamp: currentTime,
+            });
             // Call onClose callback
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
             // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
@@ -5565,6 +5663,78 @@ class ClientStrategy {
             await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, result, currentTime, this.params.execution.context.backtest);
             return result;
         }
+        // Check if scheduled signal was activated - emit opened event once
+        if (this._activatedSignal) {
+            const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+            const activatedSignal = this._activatedSignal;
+            this._activatedSignal = null; // Clear after emitting
+            this.params.logger.info("ClientStrategy tick: scheduled signal was activated", {
+                symbol: this.params.execution.context.symbol,
+                signalId: activatedSignal.id,
+            });
+            // Check if strategy was stopped (symmetry with backtest PROCESS_SCHEDULED_SIGNAL_CANDLES_FN)
+            if (this._isStopped) {
+                this.params.logger.info("ClientStrategy tick: user-activated signal cancelled (stopped)", {
+                    symbol: this.params.execution.context.symbol,
+                    signalId: activatedSignal.id,
+                });
+                await this.setScheduledSignal(null);
+                return await RETURN_IDLE_FN(this, currentPrice);
+            }
+            // Check risk before activation
+            if (await functoolsKit.not(CALL_RISK_CHECK_SIGNAL_FN(this, this.params.execution.context.symbol, activatedSignal, currentPrice, currentTime, this.params.execution.context.backtest))) {
+                this.params.logger.info("ClientStrategy tick: activated signal rejected by risk", {
+                    symbol: this.params.execution.context.symbol,
+                    signalId: activatedSignal.id,
+                });
+                return await RETURN_IDLE_FN(this, currentPrice);
+            }
+            // КРИТИЧЕСКИ ВАЖНО: обновляем pendingAt при активации
+            const pendingSignal = {
+                ...activatedSignal,
+                pendingAt: currentTime,
+                _isScheduled: false,
+            };
+            await this.setPendingSignal(pendingSignal);
+            await CALL_RISK_ADD_SIGNAL_FN(this, this.params.execution.context.symbol, pendingSignal, currentTime, this.params.execution.context.backtest);
+            // Emit commit AFTER successful risk check
+            const publicSignalForCommit = TO_PUBLIC_SIGNAL(pendingSignal);
+            await CALL_COMMIT_FN(this, {
+                action: "activate-scheduled",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: activatedSignal.id,
+                backtest: this.params.execution.context.backtest,
+                activateId: activatedSignal.activateId,
+                timestamp: currentTime,
+                currentPrice,
+                position: publicSignalForCommit.position,
+                priceOpen: publicSignalForCommit.priceOpen,
+                priceTakeProfit: publicSignalForCommit.priceTakeProfit,
+                priceStopLoss: publicSignalForCommit.priceStopLoss,
+                originalPriceTakeProfit: publicSignalForCommit.originalPriceTakeProfit,
+                originalPriceStopLoss: publicSignalForCommit.originalPriceStopLoss,
+                scheduledAt: publicSignalForCommit.scheduledAt,
+                pendingAt: publicSignalForCommit.pendingAt,
+            });
+            // Call onOpen callback
+            await CALL_OPEN_CALLBACKS_FN(this, this.params.execution.context.symbol, pendingSignal, currentPrice, currentTime, this.params.execution.context.backtest);
+            const result = {
+                action: "opened",
+                signal: TO_PUBLIC_SIGNAL(pendingSignal),
+                strategyName: this.params.method.context.strategyName,
+                exchangeName: this.params.method.context.exchangeName,
+                frameName: this.params.method.context.frameName,
+                symbol: this.params.execution.context.symbol,
+                currentPrice,
+                backtest: this.params.execution.context.backtest,
+                createdAt: currentTime,
+            };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, result, currentTime, this.params.execution.context.backtest);
+            return result;
+        }
         // Monitor scheduled signal
         if (this._scheduledSignal && !this._pendingSignal) {
             const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
@@ -5588,7 +5758,12 @@ class ClientStrategy {
             return await RETURN_SCHEDULED_SIGNAL_ACTIVE_FN(this, this._scheduledSignal, currentPrice);
         }
         // Generate new signal if none exists
+        // NOTE: _isStopped blocks NEW signal generation but allows existing positions to continue
         if (!this._pendingSignal && !this._scheduledSignal) {
+            if (this._isStopped) {
+                const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+                return await RETURN_IDLE_FN(this, currentPrice);
+            }
             const signal = await GET_SIGNAL_FN(this);
             if (signal) {
                 if (signal._isScheduled === true) {
@@ -5662,6 +5837,18 @@ class ClientStrategy {
             const cancelledSignal = this._cancelledSignal;
             this._cancelledSignal = null; // Clear after using
             const closeTimestamp = this.params.execution.context.when.getTime();
+            // Emit commit with correct timestamp from backtest context
+            await CALL_COMMIT_FN(this, {
+                action: "cancel-scheduled",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: cancelledSignal.id,
+                backtest: true,
+                cancelId: cancelledSignal.cancelId,
+                timestamp: closeTimestamp,
+            });
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             const cancelledResult = {
                 action: "cancelled",
@@ -5687,6 +5874,18 @@ class ClientStrategy {
             const closedSignal = this._closedSignal;
             this._closedSignal = null; // Clear after using
             const closeTimestamp = this.params.execution.context.when.getTime();
+            // Emit commit with correct timestamp from backtest context
+            await CALL_COMMIT_FN(this, {
+                action: "close-pending",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: closedSignal.id,
+                backtest: true,
+                closeId: closedSignal.closeId,
+                timestamp: closeTimestamp,
+            });
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
             await CALL_PARTIAL_CLEAR_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
@@ -5847,8 +6046,18 @@ class ClientStrategy {
             symbol,
             hasPendingSignal: this._pendingSignal !== null,
             hasScheduledSignal: this._scheduledSignal !== null,
+            hasActivatedSignal: this._activatedSignal !== null,
+            hasCancelledSignal: this._cancelledSignal !== null,
+            hasClosedSignal: this._closedSignal !== null,
         });
         this._isStopped = true;
+        // Clear pending flags to start from clean state
+        // NOTE: _isStopped blocks NEW position opening, but allows:
+        // - cancelScheduled() / closePending() for graceful shutdown
+        // - Monitoring existing _pendingSignal until TP/SL/timeout
+        this._activatedSignal = null;
+        this._cancelledSignal = null;
+        this._closedSignal = null;
         // Clear scheduled signal if exists
         if (!this._scheduledSignal) {
             return;
@@ -5886,8 +6095,9 @@ class ClientStrategy {
             hasScheduledSignal: this._scheduledSignal !== null,
             cancelId,
         });
-        // Save cancelled signal for next tick to emit cancelled event
-        const hadScheduledSignal = this._scheduledSignal !== null;
+        // NOTE: No _isStopped check - cancellation must work for graceful shutdown
+        // (cancelling scheduled signal is not opening new position)
+        // Save cancelled signal for next tick/backtest to emit cancelled event with correct timestamp
         if (this._scheduledSignal) {
             this._cancelledSignal = Object.assign({}, this._scheduledSignal, {
                 cancelId,
@@ -5895,37 +6105,60 @@ class ClientStrategy {
             this._scheduledSignal = null;
         }
         if (backtest) {
-            // Emit commit event only if signal was actually cancelled
-            if (hadScheduledSignal) {
-                await CALL_COMMIT_FN(this, {
-                    action: "cancel-scheduled",
-                    symbol,
-                    strategyName: this.params.strategyName,
-                    exchangeName: this.params.exchangeName,
-                    frameName: this.params.frameName,
-                    signalId: this._cancelledSignal.id,
-                    backtest,
-                    cancelId,
-                    timestamp: this.params.execution.context.when.getTime(),
-                });
-            }
+            // Commit will be emitted in backtest() with correct candle timestamp
             return;
         }
         await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
-        // Emit commit event only if signal was actually cancelled
-        if (hadScheduledSignal) {
-            await CALL_COMMIT_FN(this, {
-                action: "cancel-scheduled",
+        // Commit will be emitted in tick() with correct currentTime
+    }
+    /**
+     * Activates the scheduled signal without waiting for price to reach priceOpen.
+     *
+     * Forces immediate activation of the scheduled signal at the current price.
+     * Does NOT affect active pending signals or strategy operation.
+     * Does NOT set stop flag - strategy can continue generating new signals.
+     *
+     * Use case: User-initiated early activation of a scheduled entry.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param backtest - Whether running in backtest mode
+     * @param activateId - Optional identifier for this activation operation
+     * @returns Promise that resolves when scheduled signal is activated
+     *
+     * @example
+     * ```typescript
+     * // Activate scheduled signal without waiting for priceOpen
+     * await strategy.activateScheduled("BTCUSDT", false, "user-activate-123");
+     * // Scheduled signal becomes pending signal immediately
+     * ```
+     */
+    async activateScheduled(symbol, backtest, activateId) {
+        this.params.logger.debug("ClientStrategy activateScheduled", {
+            symbol,
+            hasScheduledSignal: this._scheduledSignal !== null,
+            activateId,
+        });
+        // Block activation if strategy stopped - activation = opening NEW position
+        // (unlike cancelScheduled/closePending which handle existing signals for graceful shutdown)
+        if (this._isStopped) {
+            this.params.logger.debug("ClientStrategy activateScheduled: strategy stopped, skipping", {
                 symbol,
-                strategyName: this.params.strategyName,
-                exchangeName: this.params.exchangeName,
-                frameName: this.params.frameName,
-                signalId: this._cancelledSignal.id,
-                backtest,
-                cancelId,
-                timestamp: this.params.execution.context.when.getTime(),
             });
+            return;
+        }
+        // Save activated signal for next tick to emit opened event
+        if (this._scheduledSignal) {
+            this._activatedSignal = Object.assign({}, this._scheduledSignal, {
+                activateId,
+            });
+            this._scheduledSignal = null;
+        }
+        if (backtest) {
+            // Commit will be emitted AFTER successful risk check in PROCESS_SCHEDULED_SIGNAL_CANDLES_FN
+            return;
         }
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
+        // Commit will be emitted AFTER successful risk check in tick()
     }
     /**
      * Closes the pending signal without stopping the strategy.
@@ -5954,8 +6187,8 @@ class ClientStrategy {
             hasPendingSignal: this._pendingSignal !== null,
             closeId,
         });
-        // Save closed signal for next tick to emit closed event
-        const hadPendingSignal = this._pendingSignal !== null;
+        // NOTE: No _isStopped check - closing position must work for graceful shutdown
+        // Save closed signal for next tick/backtest to emit closed event with correct timestamp
         if (this._pendingSignal) {
             this._closedSignal = Object.assign({}, this._pendingSignal, {
                 closeId,
@@ -5963,37 +6196,11 @@ class ClientStrategy {
             this._pendingSignal = null;
         }
         if (backtest) {
-            // Emit commit event only if signal was actually closed
-            if (hadPendingSignal) {
-                await CALL_COMMIT_FN(this, {
-                    action: "close-pending",
-                    symbol,
-                    strategyName: this.params.strategyName,
-                    exchangeName: this.params.exchangeName,
-                    frameName: this.params.frameName,
-                    signalId: this._closedSignal.id,
-                    backtest,
-                    closeId,
-                    timestamp: this.params.execution.context.when.getTime(),
-                });
-            }
+            // Commit will be emitted in backtest() with correct candle timestamp
             return;
         }
         await PersistSignalAdapter.writeSignalData(this._pendingSignal, symbol, this.params.strategyName, this.params.exchangeName);
-        // Emit commit event only if signal was actually closed
-        if (hadPendingSignal) {
-            await CALL_COMMIT_FN(this, {
-                action: "close-pending",
-                symbol,
-                strategyName: this.params.strategyName,
-                exchangeName: this.params.exchangeName,
-                frameName: this.params.frameName,
-                signalId: this._closedSignal.id,
-                backtest,
-                closeId,
-                timestamp: this.params.execution.context.when.getTime(),
-            });
-        }
+        // Commit will be emitted in tick() with correct currentTime
     }
     /**
      * Executes partial close at profit level (moving toward TP).
@@ -7832,6 +8039,39 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.breakeven(symbol, currentPrice, backtest);
         };
+        /**
+         * Activates a scheduled signal early without waiting for price to reach priceOpen.
+         *
+         * Delegates to ClientStrategy.activateScheduled() which sets _activatedSignal flag.
+         * The actual activation happens on next tick() when strategy detects the flag.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @param activateId - Optional identifier for the activation reason
+         * @returns Promise that resolves when activation flag is set
+         *
+         * @example
+         * ```typescript
+         * // Activate scheduled signal early
+         * await strategyConnectionService.activateScheduled(
+         *   false,
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" },
+         *   "manual-activation"
+         * );
+         * ```
+         */
+        this.activateScheduled = async (backtest, symbol, context, activateId) => {
+            this.loggerService.log("strategyConnectionService activateScheduled", {
+                symbol,
+                context,
+                backtest,
+                activateId,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.activateScheduled(symbol, backtest, activateId);
+        };
     }
 }
 
@@ -11144,6 +11384,39 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.breakeven(backtest, symbol, currentPrice, context);
         };
+        /**
+         * Activates a scheduled signal early without waiting for price to reach priceOpen.
+         *
+         * Validates strategy existence and delegates to connection service
+         * to set the activation flag. The actual activation happens on next tick().
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @param activateId - Optional identifier for the activation reason
+         * @returns Promise that resolves when activation flag is set
+         *
+         * @example
+         * ```typescript
+         * // Activate scheduled signal early
+         * await strategyCoreService.activateScheduled(
+         *   false,
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" },
+         *   "manual-activation"
+         * );
+         * ```
+         */
+        this.activateScheduled = async (backtest, symbol, context, activateId) => {
+            this.loggerService.log("strategyCoreService activateScheduled", {
+                symbol,
+                context,
+                backtest,
+                activateId,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.activateScheduled(backtest, symbol, context, activateId);
+        };
     }
 }
 
@@ -12423,6 +12696,8 @@ class WalkerSchemaService {
     }
 }
 
+const ACTIVE_CANDLE_INCLUDED = 1;
+const SCHEDULE_ACTIVATION_CANDLE_SKIP = 1;
 /**
  * Private service for backtest orchestration using async generators.
  *
@@ -12546,9 +12821,9 @@ class BacktestLogicPrivateService {
                 // - CC_SCHEDULE_AWAIT_MINUTES для ожидания активации
                 // - minuteEstimatedTime для работы сигнала ПОСЛЕ активации
                 // - +1 потому что when включается как первая свеча
-                const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
+                const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - ACTIVE_CANDLE_INCLUDED;
                 const bufferStartTime = new Date(when.getTime() - bufferMinutes * 60 * 1000);
-                const candlesNeeded = bufferMinutes + GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES + signal.minuteEstimatedTime + 1;
+                const candlesNeeded = bufferMinutes + GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES + signal.minuteEstimatedTime + SCHEDULE_ACTIVATION_CANDLE_SKIP;
                 let candles;
                 try {
                     candles = await this.exchangeCoreService.getNextCandles(symbol, "1m", candlesNeeded, bufferStartTime, true);
@@ -12686,7 +12961,7 @@ class BacktestLogicPrivateService {
                 // КРИТИЧНО: Получаем свечи включая буфер для VWAP
                 // Сдвигаем начало назад на CC_AVG_PRICE_CANDLES_COUNT-1 минут для буфера VWAP
                 // Запрашиваем minuteEstimatedTime + буфер свечей одним запросом
-                const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
+                const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - ACTIVE_CANDLE_INCLUDED;
                 const bufferStartTime = new Date(when.getTime() - bufferMinutes * 60 * 1000);
                 const totalCandles = signal.minuteEstimatedTime + GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
                 let candles;
@@ -24376,6 +24651,67 @@ class StrategyReportService {
                 walkerName: "",
             });
         };
+        /**
+         * Logs an activate-scheduled event when a scheduled signal is activated early.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param currentPrice - Current market price at time of activation
+         * @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 - Entry price for the position
+         * @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
+         * @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.loggerService.log("strategyReportService activateScheduled", {
+                symbol,
+                currentPrice,
+                isBacktest,
+                activateId,
+            });
+            if (!this.subscribe.hasValue()) {
+                return;
+            }
+            const scheduledRow = await this.strategyCoreService.getScheduledSignal(isBacktest, symbol, {
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+            });
+            if (!scheduledRow) {
+                return;
+            }
+            const createdAt = new Date(timestamp).toISOString();
+            await Report.writeData("strategy", {
+                action: "activate-scheduled",
+                activateId,
+                currentPrice,
+                symbol,
+                timestamp,
+                createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
+            }, {
+                signalId: scheduledRow.id,
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+                strategyName: context.strategyName,
+                symbol,
+                walkerName: "",
+            });
+        };
         /**
          * Initializes the service for event logging.
          *
@@ -24435,7 +24771,14 @@ class StrategyReportService {
                 frameName: event.frameName,
                 strategyName: event.strategyName,
             }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
-            const disposeFn = functoolsKit.compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven());
+            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 = functoolsKit.compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled());
             return () => {
                 disposeFn();
                 this.subscribe.clear();
@@ -24566,6 +24909,7 @@ class ReportStorage {
                 trailingStopCount: 0,
                 trailingTakeCount: 0,
                 breakevenCount: 0,
+                activateScheduledCount: 0,
             };
         }
         return {
@@ -24578,6 +24922,7 @@ class ReportStorage {
             trailingStopCount: this._eventList.filter(e => e.action === "trailing-stop").length,
             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,
         };
     }
     /**
@@ -24626,6 +24971,7 @@ class ReportStorage {
             `- Trailing stop: ${stats.trailingStopCount}`,
             `- Trailing take: ${stats.trailingTakeCount}`,
             `- Breakeven: ${stats.breakevenCount}`,
+            `- Activate scheduled: ${stats.activateScheduledCount}`,
         ].join("\n");
     }
     /**
@@ -25092,6 +25438,66 @@ class StrategyMarkdownService {
                 pendingAt,
             });
         };
+        /**
+         * Records an activate-scheduled event when a scheduled signal is activated early.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param currentPrice - Current market price at time of activation
+         * @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 - Entry price for the position
+         * @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
+         * @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.loggerService.log("strategyMarkdownService activateScheduled", {
+                symbol,
+                currentPrice,
+                isBacktest,
+                activateId,
+            });
+            if (!this.subscribe.hasValue()) {
+                return;
+            }
+            const scheduledRow = await this.strategyCoreService.getScheduledSignal(isBacktest, symbol, {
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+            });
+            if (!scheduledRow) {
+                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: scheduledRow.id,
+                action: "activate-scheduled",
+                activateId,
+                currentPrice,
+                createdAt,
+                backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
+            });
+        };
         /**
          * Retrieves aggregated statistics from accumulated strategy events.
          *
@@ -25265,7 +25671,14 @@ class StrategyMarkdownService {
                 frameName: event.frameName,
                 strategyName: event.strategyName,
             }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
-            const disposeFn = functoolsKit.compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven());
+            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 = functoolsKit.compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled());
             return () => {
                 disposeFn();
                 this.subscribe.clear();
@@ -26191,6 +26604,7 @@ const PARTIAL_LOSS_METHOD_NAME = "strategy.commitPartialLoss";
 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";
 /**
  * Cancels the scheduled signal without stopping the strategy.
  *
@@ -26508,6 +26922,41 @@ async function commitBreakeven(symbol) {
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     return await bt.strategyCoreService.breakeven(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
 }
+/**
+ * Activates a scheduled signal early without waiting for price to reach priceOpen.
+ *
+ * Sets the activation flag on the scheduled signal. The actual activation
+ * happens on the next tick() when strategy detects the flag.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param activateId - Optional activation ID for tracking user-initiated activations
+ * @returns Promise that resolves when activation flag is set
+ *
+ * @example
+ * ```typescript
+ * import { commitActivateScheduled } from "backtest-kit";
+ *
+ * // Activate scheduled signal early with custom ID
+ * await commitActivateScheduled("BTCUSDT", "manual-activate-001");
+ * ```
+ */
+async function commitActivateScheduled(symbol, activateId) {
+    bt.loggerService.info(ACTIVATE_SCHEDULED_METHOD_NAME, {
+        symbol,
+        activateId,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitActivateScheduled requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitActivateScheduled requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    await bt.strategyCoreService.activateScheduled(isBacktest, symbol, { exchangeName, frameName, strategyName }, activateId);
+}
 
 const STOP_STRATEGY_METHOD_NAME = "control.stopStrategy";
 /**
@@ -28678,6 +29127,7 @@ const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.commitPartialProfit";
 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_GET_DATA = "BacktestUtils.getData";
 /**
  * Internal task function that runs backtest and handles completion.
@@ -29534,6 +29984,46 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.breakeven(true, symbol, currentPrice, context);
         };
+        /**
+         * Activates a scheduled signal early without waiting for price to reach priceOpen.
+         *
+         * Sets the activation flag on the scheduled signal. The actual activation
+         * happens on the next tick() when strategy detects the flag.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @param activateId - Optional activation ID for tracking user-initiated activations
+         * @returns Promise that resolves when activation flag is set
+         *
+         * @example
+         * ```typescript
+         * // Activate scheduled signal early with custom ID
+         * await Backtest.commitActivateScheduled("BTCUSDT", {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance",
+         *   frameName: "1h"
+         * }, "manual-activate-001");
+         * ```
+         */
+        this.commitActivateScheduled = async (symbol, context, activateId) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED, {
+                symbol,
+                context,
+                activateId,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED));
+            }
+            await bt.strategyCoreService.activateScheduled(true, symbol, context, activateId);
+        };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
          *
@@ -29709,6 +30199,7 @@ const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.commitPartialProfit";
 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";
 /**
  * Internal task function that runs live trading and handles completion.
  * Consumes live trading results and updates instance state flags.
@@ -30533,6 +31024,46 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Activates a scheduled signal early without waiting for price to reach priceOpen.
+         *
+         * Sets the activation flag on the scheduled signal. The actual activation
+         * happens on the next tick() when strategy detects the flag.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @param activateId - Optional activation ID for tracking user-initiated activations
+         * @returns Promise that resolves when activation flag is set
+         *
+         * @example
+         * ```typescript
+         * // Activate scheduled signal early with custom ID
+         * await Live.commitActivateScheduled("BTCUSDT", {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance"
+         * }, "manual-activate-001");
+         * ```
+         */
+        this.commitActivateScheduled = async (symbol, context, activateId) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_ACTIVATE_SCHEDULED, {
+                symbol,
+                context,
+                activateId,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED));
+            }
+            await bt.strategyCoreService.activateScheduled(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }, activateId);
+        };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
          *
@@ -34468,6 +34999,29 @@ class NotificationInstance {
                     createdAt: data.timestamp,
                 });
             }
+            else if (data.action === "activate-scheduled") {
+                this._addNotification({
+                    type: "activate_scheduled.commit",
+                    id: CREATE_KEY_FN(),
+                    timestamp: data.timestamp,
+                    backtest: data.backtest,
+                    symbol: data.symbol,
+                    strategyName: data.strategyName,
+                    exchangeName: data.exchangeName,
+                    signalId: data.signalId,
+                    activateId: data.activateId,
+                    currentPrice: data.currentPrice,
+                    position: data.position,
+                    priceOpen: data.priceOpen,
+                    priceTakeProfit: data.priceTakeProfit,
+                    priceStopLoss: data.priceStopLoss,
+                    originalPriceTakeProfit: data.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.originalPriceStopLoss,
+                    scheduledAt: data.scheduledAt,
+                    pendingAt: data.pendingAt,
+                    createdAt: data.timestamp,
+                });
+            }
         };
         /**
          * Processes risk rejection events.
@@ -35313,6 +35867,7 @@ exports.addRiskSchema = addRiskSchema;
 exports.addSizingSchema = addSizingSchema;
 exports.addStrategySchema = addStrategySchema;
 exports.addWalkerSchema = addWalkerSchema;
+exports.commitActivateScheduled = commitActivateScheduled;
 exports.commitBreakeven = commitBreakeven;
 exports.commitCancelScheduled = commitCancelScheduled;
 exports.commitClosePending = commitClosePending;