backtest-kit 5.9.0 → 5.11.0

package/build/index.cjs

@@ -575,6 +575,16 @@ const GLOBAL_CONFIG = {
      * Default: false (PPPL logic is only applied when it does not break the direction of exits, ensuring clearer profit/loss outcomes)
      */
     CC_ENABLE_PPPL_EVERYWHERE: false,
+    /**
+     * Enables trailing logic (Trailing Take / Trailing Stop) without requiring absorption conditions.
+     * Allows trailing mechanisms to be activated regardless of whether absorption has been detected.
+     *
+     * This can lead to earlier or more frequent trailing activation, improving reactivity to price movement,
+     * but may increase sensitivity to noise and result in premature exits.
+     *
+     * Default: false (trailing logic is applied only when absorption conditions are met)
+     */
+    CC_ENABLE_TRAILING_EVERYWHERE: false,
     /**
      * Cost of entering a position (in USD).
      * This is used as a default value for calculating position size and risk management when cost data is not provided by the strategy
@@ -889,6 +899,8 @@ const INTERVAL_MINUTES$8 = {
     "4h": 240,
     "6h": 360,
     "8h": 480,
+    "1d": 1440,
+    "1w": 10080,
 };
 const MS_PER_MINUTE$6 = 60000;
 const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER = "PersistSignalUtils.usePersistSignalAdapter";
@@ -2642,6 +2654,8 @@ const INTERVAL_MINUTES$7 = {
     "4h": 240,
     "6h": 360,
     "8h": 480,
+    "1d": 1440,
+    "1w": 10080,
 };
 /**
  * Aligns timestamp down to the nearest interval boundary.
@@ -3928,6 +3942,390 @@ const beginTime = (run) => (...args) => {
     return fn();
 };
 
+/**
+ * Validates the common fields of ISignalDto that apply to both pending and scheduled signals.
+ *
+ * Checks:
+ * - position is "long" or "short"
+ * - priceOpen, priceTakeProfit, priceStopLoss are finite positive numbers
+ * - price relationships are correct for position direction (TP/SL on correct sides of priceOpen)
+ * - TP/SL distance constraints from GLOBAL_CONFIG
+ * - minuteEstimatedTime is valid
+ *
+ * Does NOT check:
+ * - currentPrice vs SL/TP (immediate close protection — handled by pending/scheduled validators)
+ * - ISignalRow-specific fields: id, exchangeName, strategyName, symbol, _isScheduled, scheduledAt, pendingAt
+ *
+ * @deprecated This is an internal code exported for unit tests only. Use `validateSignal` in Strategy::getSignal
+ *
+ * @param signal - Signal DTO to validate
+ * @returns Array of error strings (empty if valid)
+ */
+const validateCommonSignal = (signal) => {
+    const errors = [];
+    // Валидация position
+    {
+        if (signal.position === undefined || signal.position === null) {
+            errors.push('position is required and must be "long" or "short"');
+        }
+        if (signal.position !== "long" && signal.position !== "short") {
+            errors.push(`position must be "long" or "short", got "${signal.position}"`);
+        }
+    }
+    // ЗАЩИТА ОТ NaN/Infinity: все цены должны быть конечными числами
+    {
+        if (typeof signal.priceOpen !== "number") {
+            errors.push(`priceOpen must be a number type, got ${signal.priceOpen} (${typeof signal.priceOpen})`);
+        }
+        if (!isFinite(signal.priceOpen)) {
+            errors.push(`priceOpen must be a finite number, got ${signal.priceOpen} (${typeof signal.priceOpen})`);
+        }
+        if (typeof signal.priceTakeProfit !== "number") {
+            errors.push(`priceTakeProfit must be a number type, got ${signal.priceTakeProfit} (${typeof signal.priceTakeProfit})`);
+        }
+        if (!isFinite(signal.priceTakeProfit)) {
+            errors.push(`priceTakeProfit must be a finite number, got ${signal.priceTakeProfit} (${typeof signal.priceTakeProfit})`);
+        }
+        if (typeof signal.priceStopLoss !== "number") {
+            errors.push(`priceStopLoss must be a number type, got ${signal.priceStopLoss} (${typeof signal.priceStopLoss})`);
+        }
+        if (!isFinite(signal.priceStopLoss)) {
+            errors.push(`priceStopLoss must be a finite number, got ${signal.priceStopLoss} (${typeof signal.priceStopLoss})`);
+        }
+    }
+    // Валидация цен (только если они конечные)
+    {
+        if (isFinite(signal.priceOpen) && signal.priceOpen <= 0) {
+            errors.push(`priceOpen must be positive, got ${signal.priceOpen}`);
+        }
+        if (isFinite(signal.priceTakeProfit) && signal.priceTakeProfit <= 0) {
+            errors.push(`priceTakeProfit must be positive, got ${signal.priceTakeProfit}`);
+        }
+        if (isFinite(signal.priceStopLoss) && signal.priceStopLoss <= 0) {
+            errors.push(`priceStopLoss must be positive, got ${signal.priceStopLoss}`);
+        }
+    }
+    // Валидация для long позиции
+    if (signal.position === "long") {
+        // Проверка соотношения цен для long
+        {
+            if (signal.priceTakeProfit <= signal.priceOpen) {
+                errors.push(`Long: priceTakeProfit (${signal.priceTakeProfit}) must be > priceOpen (${signal.priceOpen})`);
+            }
+            if (signal.priceStopLoss >= signal.priceOpen) {
+                errors.push(`Long: priceStopLoss (${signal.priceStopLoss}) must be < priceOpen (${signal.priceOpen})`);
+            }
+        }
+        // ЗАЩИТА ОТ МИКРО-ПРОФИТА: TakeProfit должен быть достаточно далеко, чтобы покрыть комиссии
+        {
+            if (GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
+                const tpDistancePercent = ((signal.priceTakeProfit - signal.priceOpen) / signal.priceOpen) * 100;
+                if (tpDistancePercent < GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
+                    errors.push(`Long: TakeProfit too close to priceOpen (${tpDistancePercent.toFixed(3)}%). ` +
+                        `Minimum distance: ${GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT}% to cover trading fees. ` +
+                        `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) {
+                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)}%). ` +
+                        `Maximum distance: ${GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT}% to protect capital. ` +
+                        `Current: SL=${signal.priceStopLoss}, Open=${signal.priceOpen}`);
+                }
+            }
+        }
+    }
+    // Валидация для short позиции
+    if (signal.position === "short") {
+        // Проверка соотношения цен для short
+        {
+            if (signal.priceTakeProfit >= signal.priceOpen) {
+                errors.push(`Short: priceTakeProfit (${signal.priceTakeProfit}) must be < priceOpen (${signal.priceOpen})`);
+            }
+            if (signal.priceStopLoss <= signal.priceOpen) {
+                errors.push(`Short: priceStopLoss (${signal.priceStopLoss}) must be > priceOpen (${signal.priceOpen})`);
+            }
+        }
+        // ЗАЩИТА ОТ МИКРО-ПРОФИТА: TakeProfit должен быть достаточно далеко, чтобы покрыть комиссии
+        {
+            if (GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
+                const tpDistancePercent = ((signal.priceOpen - signal.priceTakeProfit) / signal.priceOpen) * 100;
+                if (tpDistancePercent < GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
+                    errors.push(`Short: TakeProfit too close to priceOpen (${tpDistancePercent.toFixed(3)}%). ` +
+                        `Minimum distance: ${GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT}% to cover trading fees. ` +
+                        `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) {
+                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)}%). ` +
+                        `Maximum distance: ${GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT}% to protect capital. ` +
+                        `Current: SL=${signal.priceStopLoss}, Open=${signal.priceOpen}`);
+                }
+            }
+        }
+    }
+    // Валидация временных параметров
+    {
+        if (typeof signal.minuteEstimatedTime !== "number") {
+            errors.push(`minuteEstimatedTime must be a number type, got ${signal.minuteEstimatedTime} (${typeof signal.minuteEstimatedTime})`);
+        }
+        if (signal.minuteEstimatedTime <= 0) {
+            errors.push(`minuteEstimatedTime must be positive, got ${signal.minuteEstimatedTime}`);
+        }
+        if (signal.minuteEstimatedTime === Infinity && GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES !== Infinity) {
+            errors.push(`minuteEstimatedTime cannot be Infinity when CC_MAX_SIGNAL_LIFETIME_MINUTES is not Infinity`);
+        }
+        if (signal.minuteEstimatedTime !== Infinity && !Number.isInteger(signal.minuteEstimatedTime)) {
+            errors.push(`minuteEstimatedTime must be an integer (whole number), got ${signal.minuteEstimatedTime}`);
+        }
+    }
+    // ЗАЩИТА ОТ ВЕЧНЫХ СИГНАЛОВ: ограничиваем максимальное время жизни сигнала
+    {
+        if (GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES !== Infinity && signal.minuteEstimatedTime > GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES) {
+            const days = (signal.minuteEstimatedTime / 60 / 24).toFixed(1);
+            const maxDays = (GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES / 60 / 24).toFixed(0);
+            errors.push(`minuteEstimatedTime too large (${signal.minuteEstimatedTime} minutes = ${days} days). ` +
+                `Maximum: ${GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES} minutes (${maxDays} days) to prevent strategy deadlock. ` +
+                `Eternal signals block risk limits and prevent new trades.`);
+        }
+    }
+    // Кидаем ошибку если есть проблемы
+    if (errors.length > 0) {
+        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+    }
+};
+
+/**
+ * Validates a pending (immediately active) signal before it is opened.
+ *
+ * Checks:
+ * - ISignalRow-specific fields: id, exchangeName, strategyName, symbol, _isScheduled
+ * - currentPrice is a finite positive number
+ * - Common signal fields via validateCommonSignal (position, prices, TP/SL relationships, minuteEstimatedTime)
+ * - currentPrice is between SL and TP — position would not be immediately closed on open
+ * - scheduledAt and pendingAt are positive numbers
+ *
+ * @deprecated This is an internal code exported for unit tests only. Use `validateSignal` in Strategy::getSignal
+ *
+ * @param signal - Pending signal row to validate
+ * @param currentPrice - Current market price at the moment of signal creation
+ * @throws {Error} If any validation check fails
+ */
+const validatePendingSignal = (signal, currentPrice) => {
+    const errors = [];
+    // ПРОВЕРКА ОБЯЗАТЕЛЬНЫХ ПОЛЕЙ ISignalRow
+    {
+        if (signal.id === undefined || signal.id === null || signal.id === '') {
+            errors.push('id is required and must be a non-empty string');
+        }
+        if (signal.exchangeName === undefined || signal.exchangeName === null || signal.exchangeName === '') {
+            errors.push('exchangeName is required');
+        }
+        if (signal.strategyName === undefined || signal.strategyName === null || signal.strategyName === '') {
+            errors.push('strategyName is required');
+        }
+        if (signal.symbol === undefined || signal.symbol === null || signal.symbol === '') {
+            errors.push('symbol is required and must be a non-empty string');
+        }
+        if (signal._isScheduled === undefined || signal._isScheduled === null) {
+            errors.push('_isScheduled is required');
+        }
+    }
+    // ЗАЩИТА ОТ NaN/Infinity: currentPrice должна быть конечным числом
+    {
+        if (typeof currentPrice !== "number") {
+            errors.push(`currentPrice must be a number type, got ${currentPrice} (${typeof currentPrice})`);
+        }
+        if (!isFinite(currentPrice)) {
+            errors.push(`currentPrice must be a finite number, got ${currentPrice} (${typeof currentPrice})`);
+        }
+        if (isFinite(currentPrice) && currentPrice <= 0) {
+            errors.push(`currentPrice must be positive, got ${currentPrice}`);
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+    }
+    validateCommonSignal(signal);
+    // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ: проверяем что позиция не закроется сразу после открытия
+    if (signal.position === "long") {
+        if (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.`);
+            }
+            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.`);
+            }
+        }
+    }
+    if (signal.position === "short") {
+        if (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.`);
+            }
+        }
+    }
+    // Валидация временных меток
+    {
+        if (typeof signal.scheduledAt !== "number") {
+            errors.push(`scheduledAt must be a number type, got ${signal.scheduledAt} (${typeof signal.scheduledAt})`);
+        }
+        if (signal.scheduledAt <= 0) {
+            errors.push(`scheduledAt must be positive, got ${signal.scheduledAt}`);
+        }
+        if (typeof signal.pendingAt !== "number") {
+            errors.push(`pendingAt must be a number type, got ${signal.pendingAt} (${typeof signal.pendingAt})`);
+        }
+        if (signal.pendingAt <= 0) {
+            errors.push(`pendingAt must be positive, got ${signal.pendingAt}`);
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+    }
+};
+
+/**
+ * Validates a scheduled signal before it is registered for activation.
+ *
+ * Checks:
+ * - ISignalRow-specific fields: id, exchangeName, strategyName, symbol, _isScheduled
+ * - currentPrice is a finite positive number
+ * - Common signal fields via validateCommonSignal (position, prices, TP/SL relationships, minuteEstimatedTime)
+ * - priceOpen is between SL and TP — position would not be immediately closed upon activation
+ * - scheduledAt is a positive number (pendingAt === 0 is allowed until activation)
+ *
+ * @deprecated This is an internal code exported for unit tests only. Use `validateSignal` in Strategy::getSignal
+ *
+ * @param signal - Scheduled signal row to validate
+ * @param currentPrice - Current market price at the moment of signal creation
+ * @throws {Error} If any validation check fails
+ */
+const validateScheduledSignal = (signal, currentPrice) => {
+    const errors = [];
+    // ПРОВЕРКА ОБЯЗАТЕЛЬНЫХ ПОЛЕЙ ISignalRow
+    {
+        if (signal.id === undefined || signal.id === null || signal.id === '') {
+            errors.push('id is required and must be a non-empty string');
+        }
+        if (signal.exchangeName === undefined || signal.exchangeName === null || signal.exchangeName === '') {
+            errors.push('exchangeName is required');
+        }
+        if (signal.strategyName === undefined || signal.strategyName === null || signal.strategyName === '') {
+            errors.push('strategyName is required');
+        }
+        if (signal.symbol === undefined || signal.symbol === null || signal.symbol === '') {
+            errors.push('symbol is required and must be a non-empty string');
+        }
+        if (signal._isScheduled === undefined || signal._isScheduled === null) {
+            errors.push('_isScheduled is required');
+        }
+    }
+    // ЗАЩИТА ОТ NaN/Infinity: currentPrice должна быть конечным числом
+    {
+        if (typeof currentPrice !== "number") {
+            errors.push(`currentPrice must be a number type, got ${currentPrice} (${typeof currentPrice})`);
+        }
+        if (!isFinite(currentPrice)) {
+            errors.push(`currentPrice must be a finite number, got ${currentPrice} (${typeof currentPrice})`);
+        }
+        if (isFinite(currentPrice) && currentPrice <= 0) {
+            errors.push(`currentPrice must be positive, got ${currentPrice}`);
+        }
+    }
+    if (errors.length > 0) {
+        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+    }
+    validateCommonSignal(signal);
+    // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ scheduled сигналов
+    if (signal.position === "long") {
+        if (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.`);
+            }
+        }
+    }
+    if (signal.position === "short") {
+        if (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.`);
+            }
+            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.`);
+            }
+        }
+    }
+    // Валидация временных меток
+    {
+        if (typeof signal.scheduledAt !== "number") {
+            errors.push(`scheduledAt must be a number type, got ${signal.scheduledAt} (${typeof signal.scheduledAt})`);
+        }
+        if (signal.scheduledAt <= 0) {
+            errors.push(`scheduledAt must be positive, got ${signal.scheduledAt}`);
+        }
+        if (typeof signal.pendingAt !== "number") {
+            errors.push(`pendingAt must be a number type, got ${signal.pendingAt} (${typeof signal.pendingAt})`);
+        }
+        // pendingAt === 0 is allowed for scheduled signals (set to SCHEDULED_SIGNAL_PENDING_MOCK until activation)
+    }
+    if (errors.length > 0) {
+        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+    }
+};
+
 const INTERVAL_MINUTES$6 = {
     "1m": 1,
     "3m": 3,
@@ -4306,272 +4704,6 @@ const TO_PUBLIC_SIGNAL = (signal, currentPrice) => {
         pnl: toProfitLossDto(signal, currentPrice),
     };
 };
-const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
-    const errors = [];
-    // ПРОВЕРКА ОБЯЗАТЕЛЬНЫХ ПОЛЕЙ ISignalRow
-    {
-        if (signal.id === undefined || signal.id === null || signal.id === '') {
-            errors.push('id is required and must be a non-empty string');
-        }
-        if (signal.exchangeName === undefined || signal.exchangeName === null || signal.exchangeName === '') {
-            errors.push('exchangeName is required');
-        }
-        if (signal.strategyName === undefined || signal.strategyName === null || signal.strategyName === '') {
-            errors.push('strategyName is required');
-        }
-        if (signal.symbol === undefined || signal.symbol === null || signal.symbol === '') {
-            errors.push('symbol is required and must be a non-empty string');
-        }
-        if (signal._isScheduled === undefined || signal._isScheduled === null) {
-            errors.push('_isScheduled is required');
-        }
-        if (signal.position === undefined || signal.position === null) {
-            errors.push('position is required and must be "long" or "short"');
-        }
-        if (signal.position !== "long" && signal.position !== "short") {
-            errors.push(`position must be "long" or "short", got "${signal.position}"`);
-        }
-    }
-    // ЗАЩИТА ОТ NaN/Infinity: currentPrice должна быть конечным числом
-    {
-        if (typeof currentPrice !== "number") {
-            errors.push(`currentPrice must be a number type, got ${currentPrice} (${typeof currentPrice})`);
-        }
-        if (!isFinite(currentPrice)) {
-            errors.push(`currentPrice must be a finite number, got ${currentPrice} (${typeof currentPrice})`);
-        }
-        if (isFinite(currentPrice) && currentPrice <= 0) {
-            errors.push(`currentPrice must be positive, got ${currentPrice}`);
-        }
-    }
-    // ЗАЩИТА ОТ NaN/Infinity: все цены должны быть конечными числами
-    {
-        if (typeof signal.priceOpen !== "number") {
-            errors.push(`priceOpen must be a number type, got ${signal.priceOpen} (${typeof signal.priceOpen})`);
-        }
-        if (!isFinite(signal.priceOpen)) {
-            errors.push(`priceOpen must be a finite number, got ${signal.priceOpen} (${typeof signal.priceOpen})`);
-        }
-        if (typeof signal.priceTakeProfit !== "number") {
-            errors.push(`priceTakeProfit must be a number type, got ${signal.priceTakeProfit} (${typeof signal.priceTakeProfit})`);
-        }
-        if (!isFinite(signal.priceTakeProfit)) {
-            errors.push(`priceTakeProfit must be a finite number, got ${signal.priceTakeProfit} (${typeof signal.priceTakeProfit})`);
-        }
-        if (typeof signal.priceStopLoss !== "number") {
-            errors.push(`priceStopLoss must be a number type, got ${signal.priceStopLoss} (${typeof signal.priceStopLoss})`);
-        }
-        if (!isFinite(signal.priceStopLoss)) {
-            errors.push(`priceStopLoss must be a finite number, got ${signal.priceStopLoss} (${typeof signal.priceStopLoss})`);
-        }
-    }
-    // Валидация цен (только если они конечные)
-    {
-        if (isFinite(signal.priceOpen) && signal.priceOpen <= 0) {
-            errors.push(`priceOpen must be positive, got ${signal.priceOpen}`);
-        }
-        if (isFinite(signal.priceTakeProfit) && signal.priceTakeProfit <= 0) {
-            errors.push(`priceTakeProfit must be positive, got ${signal.priceTakeProfit}`);
-        }
-        if (isFinite(signal.priceStopLoss) && signal.priceStopLoss <= 0) {
-            errors.push(`priceStopLoss must be positive, got ${signal.priceStopLoss}`);
-        }
-    }
-    // Валидация для long позиции
-    if (signal.position === "long") {
-        // Проверка соотношения цен для long
-        {
-            if (signal.priceTakeProfit <= signal.priceOpen) {
-                errors.push(`Long: priceTakeProfit (${signal.priceTakeProfit}) must be > priceOpen (${signal.priceOpen})`);
-            }
-            if (signal.priceStopLoss >= signal.priceOpen) {
-                errors.push(`Long: priceStopLoss (${signal.priceStopLoss}) must be < priceOpen (${signal.priceOpen})`);
-            }
-        }
-        // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ: проверяем что позиция не закроется сразу после открытия
-        {
-            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.`);
-                }
-                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 должен быть достаточно далеко, чтобы покрыть комиссии
-        {
-            if (GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
-                const tpDistancePercent = ((signal.priceTakeProfit - signal.priceOpen) / signal.priceOpen) * 100;
-                if (tpDistancePercent < GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
-                    errors.push(`Long: TakeProfit too close to priceOpen (${tpDistancePercent.toFixed(3)}%). ` +
-                        `Minimum distance: ${GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT}% to cover trading fees. ` +
-                        `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) {
-                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)}%). ` +
-                        `Maximum distance: ${GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT}% to protect capital. ` +
-                        `Current: SL=${signal.priceStopLoss}, Open=${signal.priceOpen}`);
-                }
-            }
-        }
-    }
-    // Валидация для short позиции
-    if (signal.position === "short") {
-        // Проверка соотношения цен для short
-        {
-            if (signal.priceTakeProfit >= signal.priceOpen) {
-                errors.push(`Short: priceTakeProfit (${signal.priceTakeProfit}) must be < priceOpen (${signal.priceOpen})`);
-            }
-            if (signal.priceStopLoss <= signal.priceOpen) {
-                errors.push(`Short: priceStopLoss (${signal.priceStopLoss}) must be > priceOpen (${signal.priceOpen})`);
-            }
-        }
-        // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ: проверяем что позиция не закроется сразу после открытия
-        {
-            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.`);
-                }
-                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 должен быть достаточно далеко, чтобы покрыть комиссии
-        {
-            if (GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
-                const tpDistancePercent = ((signal.priceOpen - signal.priceTakeProfit) / signal.priceOpen) * 100;
-                if (tpDistancePercent < GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
-                    errors.push(`Short: TakeProfit too close to priceOpen (${tpDistancePercent.toFixed(3)}%). ` +
-                        `Minimum distance: ${GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT}% to cover trading fees. ` +
-                        `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) {
-                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)}%). ` +
-                        `Maximum distance: ${GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT}% to protect capital. ` +
-                        `Current: SL=${signal.priceStopLoss}, Open=${signal.priceOpen}`);
-                }
-            }
-        }
-    }
-    // Валидация временных параметров
-    {
-        if (typeof signal.minuteEstimatedTime !== "number") {
-            errors.push(`minuteEstimatedTime must be a number type, got ${signal.minuteEstimatedTime} (${typeof signal.minuteEstimatedTime})`);
-        }
-        if (signal.minuteEstimatedTime <= 0) {
-            errors.push(`minuteEstimatedTime must be positive, got ${signal.minuteEstimatedTime}`);
-        }
-        if (signal.minuteEstimatedTime === Infinity && GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES !== Infinity) {
-            errors.push(`minuteEstimatedTime cannot be Infinity when CC_MAX_SIGNAL_LIFETIME_MINUTES is not Infinity`);
-        }
-        if (signal.minuteEstimatedTime !== Infinity && !Number.isInteger(signal.minuteEstimatedTime)) {
-            errors.push(`minuteEstimatedTime must be an integer (whole number), got ${signal.minuteEstimatedTime}`);
-        }
-    }
-    // ЗАЩИТА ОТ ВЕЧНЫХ СИГНАЛОВ: ограничиваем максимальное время жизни сигнала
-    {
-        if (GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES !== Infinity && signal.minuteEstimatedTime > GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES) {
-            const days = (signal.minuteEstimatedTime / 60 / 24).toFixed(1);
-            const maxDays = (GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES / 60 / 24).toFixed(0);
-            errors.push(`minuteEstimatedTime too large (${signal.minuteEstimatedTime} minutes = ${days} days). ` +
-                `Maximum: ${GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES} minutes (${maxDays} days) to prevent strategy deadlock. ` +
-                `Eternal signals block risk limits and prevent new trades.`);
-        }
-    }
-    // Валидация временных меток
-    {
-        if (typeof signal.scheduledAt !== "number") {
-            errors.push(`scheduledAt must be a number type, got ${signal.scheduledAt} (${typeof signal.scheduledAt})`);
-        }
-        if (signal.scheduledAt <= 0) {
-            errors.push(`scheduledAt must be positive, got ${signal.scheduledAt}`);
-        }
-        if (typeof signal.pendingAt !== "number") {
-            errors.push(`pendingAt must be a number type, got ${signal.pendingAt} (${typeof signal.pendingAt})`);
-        }
-        if (signal.pendingAt <= 0 && !isScheduled) {
-            errors.push(`pendingAt must be positive, got ${signal.pendingAt}`);
-        }
-    }
-    // Кидаем ошибку если есть проблемы
-    if (errors.length > 0) {
-        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
-    }
-};
 const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
     if (self._isStopped) {
         return null;
@@ -4637,7 +4769,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
                 _peak: { price: signal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
             };
             // Валидируем сигнал перед возвратом
-            VALIDATE_SIGNAL_FN(signalRow, currentPrice, false);
+            validatePendingSignal(signalRow, currentPrice);
             return signalRow;
         }
         // ОЖИДАНИЕ АКТИВАЦИИ: создаем scheduled signal (risk check при активации)
@@ -4662,7 +4794,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
             _peak: { price: signal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
         };
         // Валидируем сигнал перед возвратом
-        VALIDATE_SIGNAL_FN(scheduledSignalRow, currentPrice, true);
+        validateScheduledSignal(scheduledSignalRow, currentPrice);
         return scheduledSignalRow;
     }
     const signalRow = {
@@ -4684,7 +4816,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
         _peak: { price: currentPrice, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
     };
     // Валидируем сигнал перед возвратом
-    VALIDATE_SIGNAL_FN(signalRow, currentPrice, false);
+    validatePendingSignal(signalRow, currentPrice);
     return signalRow;
 }, {
     defaultValue: null,
@@ -4874,8 +5006,12 @@ const TRAILING_STOP_LOSS_FN = (self, signal, percentShift) => {
         // CRITICAL: Larger percentShift absorbs smaller one
         // For LONG: higher SL (closer to entry) absorbs lower one
         // For SHORT: lower SL (closer to entry) absorbs higher one
+        // When CC_ENABLE_TRAILING_EVERYWHERE is true, absorption check is skipped
         let shouldUpdate = false;
-        if (signal.position === "long") {
+        if (GLOBAL_CONFIG.CC_ENABLE_TRAILING_EVERYWHERE) {
+            shouldUpdate = true;
+        }
+        else if (signal.position === "long") {
             // LONG: update only if new SL is higher (better protection)
             shouldUpdate = newStopLoss > currentTrailingSL;
         }
@@ -4956,8 +5092,12 @@ const TRAILING_TAKE_PROFIT_FN = (self, signal, percentShift) => {
         // CRITICAL: Larger percentShift absorbs smaller one
         // For LONG: lower TP (closer to entry) absorbs higher one
         // For SHORT: higher TP (closer to entry) absorbs lower one
+        // When CC_ENABLE_TRAILING_EVERYWHERE is true, absorption check is skipped
         let shouldUpdate = false;
-        if (signal.position === "long") {
+        if (GLOBAL_CONFIG.CC_ENABLE_TRAILING_EVERYWHERE) {
+            shouldUpdate = true;
+        }
+        else if (signal.position === "long") {
             // LONG: update only if new TP is lower (closer to entry, more conservative)
             shouldUpdate = newTakeProfit < currentTrailingTP;
         }
@@ -6345,7 +6485,7 @@ const CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, closedSignal, aver
     await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
     return result;
 };
-const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) => {
+const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles, frameEndTime) => {
     const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
     const maxTimeToWait = GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES * 60 * 1000;
     const bufferCandlesCount = candlesCount - 1;
@@ -6358,6 +6498,11 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
         }
         const recentCandles = candles.slice(Math.max(0, i - (candlesCount - 1)), i + 1);
         const averagePrice = GET_AVG_PRICE_FN(recentCandles);
+        // Если timestamp свечи вышел за frameEndTime — отменяем scheduled сигнал
+        if (candle.timestamp > frameEndTime) {
+            const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "timeout");
+            return { outcome: "cancelled", result };
+        }
         // КРИТИЧНО: Проверяем был ли сигнал отменен пользователем через cancel()
         if (self._cancelledSignal) {
             // Сигнал был отменен через cancel() в onSchedulePing
@@ -6505,7 +6650,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
     }
     return { outcome: "pending" };
 };
-const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
+const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles, frameEndTime) => {
     const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
     const bufferCandlesCount = candlesCount - 1;
     // КРИТИЧНО: проверяем TP/SL на КАЖДОЙ свече начиная после буфера
@@ -6522,6 +6667,14 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         const startIndex = Math.max(0, i - (candlesCount - 1));
         const recentCandles = candles.slice(startIndex, i + 1);
         const averagePrice = GET_AVG_PRICE_FN(recentCandles);
+        // Если timestamp свечи вышел за frameEndTime — закрываем pending сигнал по time_expired
+        if (currentCandleTimestamp > frameEndTime) {
+            const result = await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(self, signal, averagePrice, "time_expired", currentCandleTimestamp);
+            if (!result) {
+                throw new Error(`ClientStrategy backtest: frameEndTime time_expired close rejected by sync (signalId=${signal.id}).`);
+            }
+            return result;
+        }
         // КРИТИЧНО: Проверяем был ли сигнал закрыт пользователем через closePending()
         if (self._closedSignal) {
             return await CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN(self, self._closedSignal, averagePrice, currentCandleTimestamp);
@@ -7687,7 +7840,7 @@ class ClientStrategy {
      * console.log(result.closeReason); // "take_profit" | "stop_loss" | "time_expired" | "cancelled"
      * ```
      */
-    async backtest(symbol, strategyName, candles) {
+    async backtest(symbol, strategyName, candles, frameEndTime) {
         this.params.logger.debug("ClientStrategy backtest", {
             symbol,
             strategyName,
@@ -7695,6 +7848,7 @@ class ClientStrategy {
             candlesCount: candles.length,
             hasScheduled: !!this._scheduledSignal,
             hasPending: !!this._pendingSignal,
+            frameEndTime,
         });
         if (!this.params.execution.context.backtest) {
             throw new Error("ClientStrategy backtest: running in live context");
@@ -7813,7 +7967,7 @@ class ClientStrategy {
                 priceOpen: scheduled.priceOpen,
                 position: scheduled.position,
             });
-            const scheduledResult = await PROCESS_SCHEDULED_SIGNAL_CANDLES_FN(this, scheduled, candles);
+            const scheduledResult = await PROCESS_SCHEDULED_SIGNAL_CANDLES_FN(this, scheduled, candles, frameEndTime);
             if (scheduledResult.outcome === "cancelled") {
                 return scheduledResult.result;
             }
@@ -7890,7 +8044,7 @@ class ClientStrategy {
         if (candles.length < candlesCount) {
             this.params.logger.warn(`ClientStrategy backtest: Expected at least ${candlesCount} candles for VWAP, got ${candles.length}`);
         }
-        return await PROCESS_PENDING_SIGNAL_CANDLES_FN(this, signal, candles);
+        return await PROCESS_PENDING_SIGNAL_CANDLES_FN(this, signal, candles, frameEndTime);
     }
     /**
      * Stops the strategy from generating new signals.
@@ -8685,12 +8839,15 @@ class ClientStrategy {
         if (signal.position === "short" && newStopLoss <= effectiveTakeProfit)
             return false;
         // Absorption check (mirrors TRAILING_STOP_LOSS_FN: first call is unconditional)
-        const currentTrailingSL = signal._trailingPriceStopLoss;
-        if (currentTrailingSL !== undefined) {
-            if (signal.position === "long" && newStopLoss <= currentTrailingSL)
-                return false;
-            if (signal.position === "short" && newStopLoss >= currentTrailingSL)
-                return false;
+        // When CC_ENABLE_TRAILING_EVERYWHERE is true, absorption check is skipped
+        if (!GLOBAL_CONFIG.CC_ENABLE_TRAILING_EVERYWHERE) {
+            const currentTrailingSL = signal._trailingPriceStopLoss;
+            if (currentTrailingSL !== undefined) {
+                if (signal.position === "long" && newStopLoss <= currentTrailingSL)
+                    return false;
+                if (signal.position === "short" && newStopLoss >= currentTrailingSL)
+                    return false;
+            }
         }
         return true;
     }
@@ -8932,12 +9089,15 @@ class ClientStrategy {
         if (signal.position === "short" && newTakeProfit >= effectiveStopLoss)
             return false;
         // Absorption check (mirrors TRAILING_TAKE_PROFIT_FN: first call is unconditional)
-        const currentTrailingTP = signal._trailingPriceTakeProfit;
-        if (currentTrailingTP !== undefined) {
-            if (signal.position === "long" && newTakeProfit >= currentTrailingTP)
-                return false;
-            if (signal.position === "short" && newTakeProfit <= currentTrailingTP)
-                return false;
+        // When CC_ENABLE_TRAILING_EVERYWHERE is true, absorption check is skipped
+        if (!GLOBAL_CONFIG.CC_ENABLE_TRAILING_EVERYWHERE) {
+            const currentTrailingTP = signal._trailingPriceTakeProfit;
+            if (currentTrailingTP !== undefined) {
+                if (signal.position === "long" && newTakeProfit >= currentTrailingTP)
+                    return false;
+                if (signal.position === "short" && newTakeProfit <= currentTrailingTP)
+                    return false;
+            }
         }
         return true;
     }
@@ -10283,17 +10443,18 @@ class StrategyConnectionService {
          * @param candles - Array of historical candle data to backtest
          * @returns Promise resolving to backtest result (signal or idle)
          */
-        this.backtest = async (symbol, context, candles) => {
+        this.backtest = async (symbol, context, candles, frameEndTime) => {
             const backtest = this.executionContextService.context.backtest;
             this.loggerService.log("strategyConnectionService backtest", {
                 symbol,
                 context,
                 candleCount: candles.length,
+                frameEndTime,
                 backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             await strategy.waitForInit();
-            const tick = await strategy.backtest(symbol, context.strategyName, candles);
+            const tick = await strategy.backtest(symbol, context.strategyName, candles, frameEndTime);
             {
                 await CALL_SIGNAL_EMIT_FN(this, tick, context, backtest, symbol);
             }
@@ -10960,7 +11121,8 @@ const INTERVAL_MINUTES$5 = {
     "8h": 480,
     "12h": 720,
     "1d": 1440,
-    "3d": 4320,
+    "1w": 10080,
+    "1M": 43200,
 };
 /**
  * Wrapper to call onTimeframe callback with error handling.
@@ -11379,6 +11541,8 @@ const INTERVAL_MINUTES$4 = {
     "4h": 240,
     "6h": 360,
     "8h": 480,
+    "1d": 1440,
+    "1w": 10080,
 };
 /**
  * Aligns timestamp down to the nearest interval boundary.
@@ -14228,17 +14392,18 @@ class StrategyCoreService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Closed signal result with PNL
          */
-        this.backtest = async (symbol, candles, when, backtest, context) => {
+        this.backtest = async (symbol, candles, frameEndTime, when, backtest, context) => {
             this.loggerService.log("strategyCoreService backtest", {
                 symbol,
                 candleCount: candles.length,
                 when,
                 backtest,
                 context,
+                frameEndTime,
             });
             await this.validate(context);
             return await ExecutionContextService.runInContext(async () => {
-                return await this.strategyConnectionService.backtest(symbol, context, candles);
+                return await this.strategyConnectionService.backtest(symbol, context, candles, frameEndTime);
             }, {
                 symbol,
                 when,
@@ -16231,7 +16396,9 @@ const TICK_FN = async (self, symbol, when) => {
         });
     }
     catch (error) {
-        console.error(`backtestLogicPrivateService tick failed symbol=${symbol} when=${when.toISOString()} strategyName=${self.methodContextService.context.strategyName} exchangeName=${self.methodContextService.context.exchangeName}`);
+        console.error(`backtestLogicPrivateService tick failed symbol=${symbol} when=${when.toISOString()} strategyName=${self.methodContextService.context.strategyName} exchangeName=${self.methodContextService.context.exchangeName} error=${functoolsKit.getErrorMessage(error)}`, {
+            error: functoolsKit.errorData(error),
+        });
         self.loggerService.warn("backtestLogicPrivateService tick failed", {
             symbol,
             when: when.toISOString(),
@@ -16257,9 +16424,9 @@ const GET_CANDLES_FN = async (self, symbol, candlesNeeded, bufferStartTime, logM
         return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "GET_CANDLES_FN", message: functoolsKit.getErrorMessage(error) };
     }
 };
-const BACKTEST_FN = async (self, symbol, candles, when, context, logMeta) => {
+const BACKTEST_FN = async (self, symbol, candles, frameEndTime, when, context, logMeta) => {
     try {
-        return await self.strategyCoreService.backtest(symbol, candles, when, true, context);
+        return await self.strategyCoreService.backtest(symbol, candles, frameEndTime, when, true, context);
     }
     catch (error) {
         console.error(`backtestLogicPrivateService backtest failed symbol=${symbol} when=${when.toISOString()} strategyName=${context.strategyName} exchangeName=${context.exchangeName}`);
@@ -16272,7 +16439,29 @@ const BACKTEST_FN = async (self, symbol, candles, when, context, logMeta) => {
         return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "BACKTEST_FN", message: functoolsKit.getErrorMessage(error) };
     }
 };
-const RUN_INFINITY_CHUNK_LOOP_FN = async (self, symbol, when, context, initialResult, bufferMs, signalId) => {
+const CLOSE_PENDING_FN = async (self, symbol, context, lastChunkCandles, frameEndTime, when, signalId) => {
+    try {
+        await self.strategyCoreService.closePending(true, symbol, context);
+    }
+    catch (error) {
+        const message = `closePending failed: ${functoolsKit.getErrorMessage(error)}`;
+        console.error(`backtestLogicPrivateService CLOSE_PENDING_FN: ${message} symbol=${symbol}`);
+        await errorEmitter.next(error instanceof Error ? error : new Error(message));
+        return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "CLOSE_PENDING_FN", message };
+    }
+    const result = await BACKTEST_FN(self, symbol, lastChunkCandles, frameEndTime, when, context, { signalId });
+    if ("__error__" in result) {
+        return result;
+    }
+    if (result.action === "active") {
+        const message = `signal ${signalId} still active after closePending`;
+        console.error(`backtestLogicPrivateService CLOSE_PENDING_FN: ${message} symbol=${symbol}`);
+        await errorEmitter.next(new Error(message));
+        return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "CLOSE_PENDING_FN", message };
+    }
+    return result;
+};
+const RUN_INFINITY_CHUNK_LOOP_FN = async (self, symbol, when, context, initialResult, bufferMs, signalId, frameEndTime) => {
     let backtestResult = initialResult;
     const CHUNK = GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST;
     let lastChunkCandles = [];
@@ -16283,25 +16472,14 @@ const RUN_INFINITY_CHUNK_LOOP_FN = async (self, symbol, when, context, initialRe
             return chunkCandles;
         }
         if (!chunkCandles.length) {
-            await self.strategyCoreService.closePending(true, symbol, context);
-            const result = await BACKTEST_FN(self, symbol, lastChunkCandles, when, context, { signalId });
-            if ("__error__" in result) {
-                return result;
-            }
-            if (result.action === "active") {
-                const message = `signal ${signalId} still active after closePending`;
-                console.error(`backtestLogicPrivateService RUN_INFINITY_CHUNK_LOOP_FN: ${message} symbol=${symbol}`);
-                await errorEmitter.next(new Error(message));
-                return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "RUN_INFINITY_CHUNK_LOOP_FN", message };
-            }
-            return result;
+            return await CLOSE_PENDING_FN(self, symbol, context, lastChunkCandles, frameEndTime, when, signalId);
         }
         self.loggerService.info("backtestLogicPrivateService candles fetched for infinity chunk", {
             symbol,
             signalId,
             candlesCount: chunkCandles.length,
         });
-        const chunkResult = await BACKTEST_FN(self, symbol, chunkCandles, when, context, { signalId });
+        const chunkResult = await BACKTEST_FN(self, symbol, chunkCandles, frameEndTime, when, context, { signalId });
         if ("__error__" in chunkResult) {
             return chunkResult;
         }
@@ -16346,7 +16524,7 @@ const EMIT_TIMEFRAME_PERFORMANCE_FN = async (self, symbol, timeframeStartTime, p
     });
     return currentTimestamp;
 };
-const PROCESS_SCHEDULED_SIGNAL_FN = async function* (self, symbol, when, result, previousEventTimestamp) {
+const PROCESS_SCHEDULED_SIGNAL_FN = async function* (self, symbol, when, result, previousEventTimestamp, frameEndTime) {
     const signalStartTime = performance.now();
     const signal = result.signal;
     self.loggerService.info("backtestLogicPrivateService scheduled signal detected", {
@@ -16366,6 +16544,10 @@ const PROCESS_SCHEDULED_SIGNAL_FN = async function* (self, symbol, when, result,
         console.error(`backtestLogicPrivateService scheduled signal: getCandles failed, stopping backtest symbol=${symbol} signalId=${signal.id} reason=${candles.reason} message=${candles.message}`);
         return candles;
     }
+    // No candles available for this scheduled signal — the frame ends before the signal
+    // could be evaluated. Unlike pending (Infinity) signals that require CLOSE_PENDING_FN,
+    // a scheduled signal that never activated needs no explicit cancellation: it simply
+    // did not start. Returning "skip" moves the backtest to the next timeframe.
     if (!candles.length) {
         return { type: "skip" };
     }
@@ -16407,7 +16589,7 @@ const PROCESS_SCHEDULED_SIGNAL_FN = async function* (self, symbol, when, result,
         });
     }
     try {
-        const firstResult = await BACKTEST_FN(self, symbol, candles, when, context, { signalId: signal.id });
+        const firstResult = await BACKTEST_FN(self, symbol, candles, frameEndTime, when, context, { signalId: signal.id });
         if ("__error__" in firstResult) {
             console.error(`backtestLogicPrivateService scheduled signal: backtest failed, stopping backtest symbol=${symbol} signalId=${signal.id} reason=${firstResult.reason} message=${firstResult.message}`);
             return firstResult;
@@ -16419,7 +16601,7 @@ const PROCESS_SCHEDULED_SIGNAL_FN = async function* (self, symbol, when, result,
     }
     if (backtestResult.action === "active" && signal.minuteEstimatedTime === Infinity) {
         const bufferMs = bufferMinutes * 60000;
-        const chunkResult = await RUN_INFINITY_CHUNK_LOOP_FN(self, symbol, when, context, backtestResult, bufferMs, signal.id);
+        const chunkResult = await RUN_INFINITY_CHUNK_LOOP_FN(self, symbol, when, context, backtestResult, bufferMs, signal.id, frameEndTime);
         if ("__error__" in chunkResult) {
             console.error(`backtestLogicPrivateService scheduled signal: infinity chunk loop failed, stopping backtest symbol=${symbol} signalId=${signal.id} reason=${chunkResult.reason} message=${chunkResult.message}`);
             return chunkResult;
@@ -16449,7 +16631,7 @@ const PROCESS_SCHEDULED_SIGNAL_FN = async function* (self, symbol, when, result,
     yield backtestResult;
     return { type: "closed", previousEventTimestamp: newTimestamp, closeTimestamp: backtestResult.closeTimestamp, shouldStop };
 };
-const RUN_OPENED_CHUNK_LOOP_FN = async (self, symbol, when, context, bufferStartTime, bufferMs, signalId) => {
+const RUN_OPENED_CHUNK_LOOP_FN = async (self, symbol, when, context, bufferStartTime, bufferMs, signalId, frameEndTime) => {
     const CHUNK = GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST;
     let chunkStart = bufferStartTime;
     let lastChunkCandles = [];
@@ -16470,29 +16652,14 @@ const RUN_OPENED_CHUNK_LOOP_FN = async (self, symbol, when, context, bufferStart
                 await errorEmitter.next(new Error(message));
                 return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "RUN_OPENED_CHUNK_LOOP_FN", message };
             }
-            await self.strategyCoreService.closePending(true, symbol, context);
-            const result = await BACKTEST_FN(self, symbol, lastChunkCandles, when, context, { signalId });
-            if ("__error__" in result) {
-                return result;
-            }
-            if (result.action === "active") {
-                const message = `signal ${signalId} still active after closePending`;
-                console.error(`backtestLogicPrivateService RUN_OPENED_CHUNK_LOOP_FN: ${message} symbol=${symbol}`);
-                self.loggerService.warn("backtestLogicPrivateService opened infinity: signal still active after closePending", {
-                    symbol,
-                    signalId,
-                });
-                await errorEmitter.next(new Error(message));
-                return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "RUN_OPENED_CHUNK_LOOP_FN", message };
-            }
-            return result;
+            return await CLOSE_PENDING_FN(self, symbol, context, lastChunkCandles, frameEndTime, when, signalId);
         }
         self.loggerService.info("backtestLogicPrivateService candles fetched", {
             symbol,
             signalId,
             candlesCount: chunkCandles.length,
         });
-        const chunkResult = await BACKTEST_FN(self, symbol, chunkCandles, when, context, { signalId });
+        const chunkResult = await BACKTEST_FN(self, symbol, chunkCandles, frameEndTime, when, context, { signalId });
         if ("__error__" in chunkResult) {
             return chunkResult;
         }
@@ -16503,7 +16670,7 @@ const RUN_OPENED_CHUNK_LOOP_FN = async (self, symbol, when, context, bufferStart
         chunkStart = new Date(chunkResult._backtestLastTimestamp + 60000 - bufferMs);
     }
 };
-const PROCESS_OPENED_SIGNAL_FN = async function* (self, symbol, when, result, previousEventTimestamp) {
+const PROCESS_OPENED_SIGNAL_FN = async function* (self, symbol, when, result, previousEventTimestamp, frameEndTime) {
     const signalStartTime = performance.now();
     const signal = result.signal;
     self.loggerService.info("backtestLogicPrivateService signal opened", {
@@ -16534,7 +16701,7 @@ const PROCESS_OPENED_SIGNAL_FN = async function* (self, symbol, when, result, pr
             signalId: signal.id,
             candlesCount: candles.length,
         });
-        const firstResult = await BACKTEST_FN(self, symbol, candles, when, context, { signalId: signal.id });
+        const firstResult = await BACKTEST_FN(self, symbol, candles, frameEndTime, when, context, { signalId: signal.id });
         if ("__error__" in firstResult) {
             console.error(`backtestLogicPrivateService opened signal: backtest failed, stopping backtest symbol=${symbol} signalId=${signal.id} reason=${firstResult.reason} message=${firstResult.message}`);
             return firstResult;
@@ -16543,7 +16710,7 @@ const PROCESS_OPENED_SIGNAL_FN = async function* (self, symbol, when, result, pr
     }
     else {
         const bufferMs = bufferMinutes * 60000;
-        const chunkResult = await RUN_OPENED_CHUNK_LOOP_FN(self, symbol, when, context, bufferStartTime, bufferMs, signal.id);
+        const chunkResult = await RUN_OPENED_CHUNK_LOOP_FN(self, symbol, when, context, bufferStartTime, bufferMs, signal.id, frameEndTime);
         if ("__error__" in chunkResult) {
             console.error(`backtestLogicPrivateService opened signal: chunk loop failed, stopping backtest symbol=${symbol} signalId=${signal.id} reason=${chunkResult.reason} message=${chunkResult.message}`);
             return chunkResult;
@@ -16609,86 +16776,103 @@ class BacktestLogicPrivateService {
             symbol,
         });
         const backtestStartTime = performance.now();
+        let _fatalError = null;
+        let previousEventTimestamp = null;
         const timeframes = await this.frameCoreService.getTimeframe(symbol, this.methodContextService.context.frameName);
         const totalFrames = timeframes.length;
+        let frameEndTime = timeframes[totalFrames - 1].getTime();
         let i = 0;
-        let previousEventTimestamp = null;
-        while (i < timeframes.length) {
-            const timeframeStartTime = performance.now();
-            const when = timeframes[i];
-            await EMIT_PROGRESS_FN(this, symbol, totalFrames, i);
-            if (await CHECK_STOPPED_FN(this, symbol, "before tick", { when: when.toISOString(), processedFrames: i, totalFrames })) {
-                break;
-            }
-            const result = await TICK_FN(this, symbol, when);
-            if ("__error__" in result) {
-                break;
-            }
-            if (result.action === "idle" &&
-                await functoolsKit.and(Promise.resolve(true), this.strategyCoreService.getStopped(true, symbol, {
-                    strategyName: this.methodContextService.context.strategyName,
-                    exchangeName: this.methodContextService.context.exchangeName,
-                    frameName: this.methodContextService.context.frameName,
-                }))) {
-                this.loggerService.info("backtestLogicPrivateService stopped by user request (idle state)", {
-                    symbol,
-                    when: when.toISOString(),
-                    processedFrames: i,
-                    totalFrames,
-                });
-                break;
-            }
-            if (result.action === "scheduled") {
-                yield result;
-                const r = yield* PROCESS_SCHEDULED_SIGNAL_FN(this, symbol, when, result, previousEventTimestamp);
-                if (r.type === "error") {
+        try {
+            while (i < timeframes.length) {
+                const timeframeStartTime = performance.now();
+                const when = timeframes[i];
+                await EMIT_PROGRESS_FN(this, symbol, totalFrames, i);
+                if (await CHECK_STOPPED_FN(this, symbol, "before tick", { when: when.toISOString(), processedFrames: i, totalFrames })) {
                     break;
                 }
-                if (r.type === "closed") {
-                    previousEventTimestamp = r.previousEventTimestamp;
-                    while (i < timeframes.length && timeframes[i].getTime() < r.closeTimestamp) {
-                        i++;
-                    }
-                    if (r.shouldStop) {
-                        break;
-                    }
+                const result = await TICK_FN(this, symbol, when);
+                if ("__error__" in result) {
+                    _fatalError = new Error(`[${result.reason}] ${result.message}`);
+                    break;
                 }
-            }
-            if (result.action === "opened") {
-                yield result;
-                const r = yield* PROCESS_OPENED_SIGNAL_FN(this, symbol, when, result, previousEventTimestamp);
-                if (r.type === "error") {
+                if (result.action === "idle" &&
+                    await functoolsKit.and(Promise.resolve(true), this.strategyCoreService.getStopped(true, symbol, {
+                        strategyName: this.methodContextService.context.strategyName,
+                        exchangeName: this.methodContextService.context.exchangeName,
+                        frameName: this.methodContextService.context.frameName,
+                    }))) {
+                    this.loggerService.info("backtestLogicPrivateService stopped by user request (idle state)", {
+                        symbol,
+                        when: when.toISOString(),
+                        processedFrames: i,
+                        totalFrames,
+                    });
                     break;
                 }
-                if (r.type === "closed") {
-                    previousEventTimestamp = r.previousEventTimestamp;
-                    while (i < timeframes.length && timeframes[i].getTime() < r.closeTimestamp) {
-                        i++;
+                if (result.action === "scheduled") {
+                    yield result;
+                    const r = yield* PROCESS_SCHEDULED_SIGNAL_FN(this, symbol, when, result, previousEventTimestamp, frameEndTime);
+                    if (r.type === "error") {
+                        _fatalError = new Error(`[${r.reason}] ${r.message}`);
+                        break;
                     }
-                    if (r.shouldStop) {
+                    if (r.type === "closed") {
+                        previousEventTimestamp = r.previousEventTimestamp;
+                        while (i < timeframes.length && timeframes[i].getTime() < r.closeTimestamp) {
+                            i++;
+                        }
+                        if (r.shouldStop) {
+                            break;
+                        }
+                    }
+                }
+                if (result.action === "opened") {
+                    yield result;
+                    const r = yield* PROCESS_OPENED_SIGNAL_FN(this, symbol, when, result, previousEventTimestamp, frameEndTime);
+                    if (r.type === "error") {
+                        _fatalError = new Error(`[${r.reason}] ${r.message}`);
                         break;
                     }
+                    if (r.type === "closed") {
+                        previousEventTimestamp = r.previousEventTimestamp;
+                        while (i < timeframes.length && timeframes[i].getTime() < r.closeTimestamp) {
+                            i++;
+                        }
+                        if (r.shouldStop) {
+                            break;
+                        }
+                    }
                 }
+                previousEventTimestamp = await EMIT_TIMEFRAME_PERFORMANCE_FN(this, symbol, timeframeStartTime, previousEventTimestamp);
+                i++;
             }
-            previousEventTimestamp = await EMIT_TIMEFRAME_PERFORMANCE_FN(this, symbol, timeframeStartTime, previousEventTimestamp);
-            i++;
-        }
-        // Emit final progress event (100%)
-        await EMIT_PROGRESS_FN(this, symbol, totalFrames, totalFrames);
-        // Track total backtest duration
-        const backtestEndTime = performance.now();
-        const currentTimestamp = Date.now();
-        await performanceEmitter.next({
-            timestamp: currentTimestamp,
-            previousTimestamp: previousEventTimestamp,
-            metricType: "backtest_total",
-            duration: backtestEndTime - backtestStartTime,
-            strategyName: this.methodContextService.context.strategyName,
-            exchangeName: this.methodContextService.context.exchangeName,
-            frameName: this.methodContextService.context.frameName,
-            symbol,
-            backtest: true,
-        });
+            // Emit final progress event (100%)
+            await EMIT_PROGRESS_FN(this, symbol, totalFrames, totalFrames);
+            // Track total backtest duration
+            const backtestEndTime = performance.now();
+            const currentTimestamp = Date.now();
+            await performanceEmitter.next({
+                timestamp: currentTimestamp,
+                previousTimestamp: previousEventTimestamp,
+                metricType: "backtest_total",
+                duration: backtestEndTime - backtestStartTime,
+                strategyName: this.methodContextService.context.strategyName,
+                exchangeName: this.methodContextService.context.exchangeName,
+                frameName: this.methodContextService.context.frameName,
+                symbol,
+                backtest: true,
+            });
+        }
+        catch (error) {
+            _fatalError = error;
+        }
+        finally {
+            if (_fatalError !== null) {
+                console.error(`[BacktestLogicPrivateService] Fatal error — backtest sequence broken for symbol=${symbol} ` +
+                    `strategy=${this.methodContextService.context.strategyName}`, _fatalError);
+                process.exit(-1);
+            }
+        }
     }
 }
 
@@ -16705,6 +16889,8 @@ const INTERVAL_MINUTES$3 = {
     "4h": 240,
     "6h": 360,
     "8h": 480,
+    "1d": 1440,
+    "1w": 10080,
 };
 const createEmitter = functoolsKit.memoize(([interval]) => `${interval}`, (interval) => {
     const tickSubject = new functoolsKit.Subject();
@@ -31541,6 +31727,8 @@ const INTERVAL_MINUTES$2 = {
     "4h": 240,
     "6h": 360,
     "8h": 480,
+    "1d": 1440,
+    "1w": 10080,
 };
 /**
  * Aligns timestamp down to the nearest interval boundary.
@@ -32290,6 +32478,8 @@ const INTERVAL_MINUTES$1 = {
     "4h": 240,
     "6h": 360,
     "8h": 480,
+    "1d": 1440,
+    "1w": 10080,
 };
 const ALIGN_TO_INTERVAL_FN = (timestamp, intervalMinutes) => {
     const intervalMs = intervalMinutes * MS_PER_MINUTE$1;
@@ -33344,54 +33534,144 @@ const BROKER_BASE_METHOD_NAME_ON_TRAILING_STOP = "BrokerBase.onTrailingStopCommi
 const BROKER_BASE_METHOD_NAME_ON_TRAILING_TAKE = "BrokerBase.onTrailingTakeCommit";
 const BROKER_BASE_METHOD_NAME_ON_BREAKEVEN = "BrokerBase.onBreakevenCommit";
 const BROKER_BASE_METHOD_NAME_ON_AVERAGE_BUY = "BrokerBase.onAverageBuyCommit";
+/**
+ * Wrapper around a `Partial<IBroker>` adapter instance.
+ *
+ * Implements the full `IBroker` interface but guards every method call —
+ * if the underlying adapter does not implement a given method, an error is thrown.
+ * `waitForInit` is the only exception: it is silently skipped when not implemented.
+ *
+ * Created internally by `BrokerAdapter.useBrokerAdapter` and stored as
+ * `_brokerInstance`. All `BrokerAdapter.commit*` methods delegate here
+ * after backtest-mode and enable-state checks pass.
+ */
 class BrokerProxy {
     constructor(_instance) {
         this._instance = _instance;
+        /**
+         * Calls `waitForInit` on the underlying adapter exactly once (singleshot).
+         * If the adapter does not implement `waitForInit`, the call is silently skipped.
+         *
+         * @returns Resolves when initialization is complete (or immediately if not implemented).
+         */
         this.waitForInit = functoolsKit.singleshot(async () => {
             if (this._instance.waitForInit) {
                 await this._instance.waitForInit();
+                return;
             }
         });
     }
+    /**
+     * Forwards a signal-open event to the underlying adapter.
+     * Throws if the adapter does not implement `onSignalOpenCommit`.
+     *
+     * @param payload - Signal open details: symbol, cost, position, prices, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onSignalOpenCommit`.
+     */
     async onSignalOpenCommit(payload) {
         if (this._instance.onSignalOpenCommit) {
             await this._instance.onSignalOpenCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onSignalOpenCommit is not implemented");
     }
+    /**
+     * Forwards a signal-close event to the underlying adapter.
+     * Throws if the adapter does not implement `onSignalCloseCommit`.
+     *
+     * @param payload - Signal close details: symbol, cost, position, currentPrice, pnl, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onSignalCloseCommit`.
+     */
     async onSignalCloseCommit(payload) {
         if (this._instance.onSignalCloseCommit) {
             await this._instance.onSignalCloseCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onSignalCloseCommit is not implemented");
     }
+    /**
+     * Forwards a partial-profit close event to the underlying adapter.
+     * Throws if the adapter does not implement `onPartialProfitCommit`.
+     *
+     * @param payload - Partial profit details: symbol, percentToClose, cost, currentPrice, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onPartialProfitCommit`.
+     */
     async onPartialProfitCommit(payload) {
         if (this._instance.onPartialProfitCommit) {
             await this._instance.onPartialProfitCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onPartialProfitCommit is not implemented");
     }
+    /**
+     * Forwards a partial-loss close event to the underlying adapter.
+     * Throws if the adapter does not implement `onPartialLossCommit`.
+     *
+     * @param payload - Partial loss details: symbol, percentToClose, cost, currentPrice, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onPartialLossCommit`.
+     */
     async onPartialLossCommit(payload) {
         if (this._instance.onPartialLossCommit) {
             await this._instance.onPartialLossCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onPartialLossCommit is not implemented");
     }
+    /**
+     * Forwards a trailing stop-loss update event to the underlying adapter.
+     * Throws if the adapter does not implement `onTrailingStopCommit`.
+     *
+     * @param payload - Trailing stop details: symbol, percentShift, currentPrice, newStopLossPrice, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onTrailingStopCommit`.
+     */
     async onTrailingStopCommit(payload) {
         if (this._instance.onTrailingStopCommit) {
             await this._instance.onTrailingStopCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onTrailingStopCommit is not implemented");
     }
+    /**
+     * Forwards a trailing take-profit update event to the underlying adapter.
+     * Throws if the adapter does not implement `onTrailingTakeCommit`.
+     *
+     * @param payload - Trailing take details: symbol, percentShift, currentPrice, newTakeProfitPrice, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onTrailingTakeCommit`.
+     */
     async onTrailingTakeCommit(payload) {
         if (this._instance.onTrailingTakeCommit) {
             await this._instance.onTrailingTakeCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onTrailingTakeCommit is not implemented");
     }
+    /**
+     * Forwards a breakeven event to the underlying adapter.
+     * Throws if the adapter does not implement `onBreakevenCommit`.
+     *
+     * @param payload - Breakeven details: symbol, currentPrice, newStopLossPrice (= effectivePriceOpen), newTakeProfitPrice, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onBreakevenCommit`.
+     */
     async onBreakevenCommit(payload) {
         if (this._instance.onBreakevenCommit) {
             await this._instance.onBreakevenCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onBreakevenCommit is not implemented");
     }
+    /**
+     * Forwards a DCA average-buy entry event to the underlying adapter.
+     * Throws if the adapter does not implement `onAverageBuyCommit`.
+     *
+     * @param payload - Average buy details: symbol, currentPrice, cost, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onAverageBuyCommit`.
+     */
     async onAverageBuyCommit(payload) {
         if (this._instance.onAverageBuyCommit) {
             await this._instance.onAverageBuyCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onAverageBuyCommit is not implemented");
     }
 }
 /**
@@ -43163,7 +43443,7 @@ class MemoryLocalInstance {
      * @param value - Value to store and index
      * @param index - Optional BM25 index string; defaults to JSON.stringify(value)
      */
-    async writeMemory(memoryId, value, index) {
+    async writeMemory(memoryId, value, description) {
         bt.loggerService.debug(MEMORY_LOCAL_INSTANCE_METHOD_NAME_WRITE, {
             signalId: this.signalId,
             bucketName: this.bucketName,
@@ -43172,7 +43452,7 @@ class MemoryLocalInstance {
         this._index.upsert({
             id: memoryId,
             content: value,
-            index: index ?? JSON.stringify(value),
+            index: description,
             priority: Date.now(),
         });
     }
@@ -43471,7 +43751,7 @@ class MemoryAdapter {
          * @param dto.value - Value to store
          * @param dto.signalId - Signal identifier
          * @param dto.bucketName - Bucket name
-         * @param dto.index - Optional BM25 index string; defaults to JSON.stringify(value)
+         * @param dto.description - Optional BM25 index string; defaults to JSON.stringify(value)
          */
         this.writeMemory = async (dto) => {
             if (!this.enable.hasValue()) {
@@ -43486,7 +43766,7 @@ class MemoryAdapter {
             const isInitial = !this.getInstance.has(key);
             const instance = this.getInstance(dto.signalId, dto.bucketName);
             await instance.waitForInit(isInitial);
-            return await instance.writeMemory(dto.memoryId, dto.value, dto.index);
+            return await instance.writeMemory(dto.memoryId, dto.value, dto.description);
         };
         /**
          * Search memory using BM25 full-text scoring.
@@ -43637,7 +43917,7 @@ const REMOVE_MEMORY_METHOD_NAME = "memory.removeMemory";
  * ```
  */
 async function writeMemory(dto) {
-    const { bucketName, memoryId, value } = dto;
+    const { bucketName, memoryId, value, description } = dto;
     bt.loggerService.info(WRITE_MEMORY_METHOD_NAME, {
         bucketName,
         memoryId,
@@ -43661,6 +43941,7 @@ async function writeMemory(dto) {
         value,
         signalId: signal.id,
         bucketName,
+        description,
     });
 }
 /**
@@ -44104,7 +44385,7 @@ class DumpMemoryInstance {
             bucketName: this.bucketName,
             signalId: this.signalId,
             value: { messages },
-            index: description,
+            description,
         });
     }
     /**
@@ -44125,7 +44406,7 @@ class DumpMemoryInstance {
             bucketName: this.bucketName,
             signalId: this.signalId,
             value: record,
-            index: description,
+            description,
         });
     }
     /**
@@ -44147,7 +44428,7 @@ class DumpMemoryInstance {
             bucketName: this.bucketName,
             signalId: this.signalId,
             value: { rows },
-            index: description,
+            description,
         });
     }
     /**
@@ -44168,7 +44449,7 @@ class DumpMemoryInstance {
             bucketName: this.bucketName,
             signalId: this.signalId,
             value: { content },
-            index: description,
+            description,
         });
     }
     /**
@@ -44189,7 +44470,7 @@ class DumpMemoryInstance {
             bucketName: this.bucketName,
             signalId: this.signalId,
             value: { content },
-            index: description,
+            description,
         });
     }
     /**
@@ -44211,7 +44492,7 @@ class DumpMemoryInstance {
             bucketName: this.bucketName,
             signalId: this.signalId,
             value: json,
-            index: description,
+            description,
         });
     }
     /** Releases resources held by this instance. */
@@ -50634,6 +50915,8 @@ const INTERVAL_MINUTES = {
     "4h": 240,
     "6h": 360,
     "8h": 480,
+    "1d": 1440,
+    "1w": 10080,
 };
 /**
  * Aligns timestamp down to the nearest interval boundary.
@@ -51708,6 +51991,119 @@ const percentValue = (yesterdayValue, todayValue) => {
     return yesterdayValue / todayValue - 1;
 };
 
+/**
+ * Validates ISignalDto returned by getSignal, branching on the same logic as ClientStrategy GET_SIGNAL_FN.
+ *
+ * When priceOpen is provided:
+ *   - If currentPrice already reached priceOpen (shouldActivateImmediately) →
+ *     validates as pending: currentPrice must be between SL and TP
+ *   - Otherwise → validates as scheduled: priceOpen must be between SL and TP
+ *
+ * When priceOpen is absent:
+ *   - Validates as pending: currentPrice must be between SL and TP
+ *
+ * Checks:
+ * - currentPrice is a finite positive number
+ * - Common signal fields via validateCommonSignal (position, prices, TP/SL relationships, minuteEstimatedTime)
+ * - Position-specific immediate-close protection (pending) or activation-close protection (scheduled)
+ *
+ * @param signal - Signal DTO returned by getSignal
+ * @param currentPrice - Current market price at the moment of signal creation
+ * @returns true if signal is valid, false if validation errors were found (errors logged to console.error)
+ */
+const validateSignal = (signal, currentPrice) => {
+    const errors = [];
+    // ЗАЩИТА ОТ NaN/Infinity: currentPrice должна быть конечным числом
+    {
+        if (typeof currentPrice !== "number") {
+            errors.push(`currentPrice must be a number type, got ${currentPrice} (${typeof currentPrice})`);
+        }
+        if (!isFinite(currentPrice)) {
+            errors.push(`currentPrice must be a finite number, got ${currentPrice} (${typeof currentPrice})`);
+        }
+        if (isFinite(currentPrice) && currentPrice <= 0) {
+            errors.push(`currentPrice must be positive, got ${currentPrice}`);
+        }
+    }
+    if (errors.length > 0) {
+        console.error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        return false;
+    }
+    try {
+        validateCommonSignal(signal);
+    }
+    catch (error) {
+        console.error(functoolsKit.getErrorMessage(error));
+        return false;
+    }
+    // Определяем режим валидации по той же логике что в GET_SIGNAL_FN:
+    // - нет priceOpen → pending (открывается по currentPrice)
+    // - priceOpen задан и уже достигнут (shouldActivateImmediately) → pending
+    // - priceOpen задан и ещё не достигнут → scheduled
+    const hasPriceOpen = signal.priceOpen !== undefined;
+    const shouldActivateImmediately = hasPriceOpen && ((signal.position === "long" && currentPrice <= signal.priceOpen) ||
+        (signal.position === "short" && currentPrice >= signal.priceOpen));
+    const isScheduled = hasPriceOpen && !shouldActivateImmediately;
+    if (isScheduled) {
+        // Scheduled: priceOpen должен быть между SL и TP (активация не даст моментального закрытия)
+        if (signal.position === "long") {
+            if (isFinite(signal.priceOpen)) {
+                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.`);
+                }
+            }
+        }
+        if (signal.position === "short") {
+            if (isFinite(signal.priceOpen)) {
+                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.`);
+                }
+                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.`);
+                }
+            }
+        }
+    }
+    else {
+        // Pending: currentPrice должна быть между SL и TP (позиция не закроется сразу после открытия)
+        if (signal.position === "long") {
+            if (isFinite(currentPrice)) {
+                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.`);
+                }
+                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.`);
+                }
+            }
+        }
+        if (signal.position === "short") {
+            if (isFinite(currentPrice)) {
+                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.`);
+                }
+            }
+        }
+    }
+    if (errors.length > 0) {
+        console.error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+    }
+    return !errors.length;
+};
+
 exports.ActionBase = ActionBase;
 exports.Backtest = Backtest;
 exports.Breakeven = Breakeven;
@@ -51913,6 +52309,10 @@ exports.toProfitLossDto = toProfitLossDto;
 exports.tpPercentShiftToPrice = tpPercentShiftToPrice;
 exports.tpPriceToPercentShift = tpPriceToPercentShift;
 exports.validate = validate;
+exports.validateCommonSignal = validateCommonSignal;
+exports.validatePendingSignal = validatePendingSignal;
+exports.validateScheduledSignal = validateScheduledSignal;
+exports.validateSignal = validateSignal;
 exports.waitForCandle = waitForCandle;
 exports.warmCandles = warmCandles;
 exports.writeMemory = writeMemory;