backtest-kit 1.1.9 → 1.2.1

package/build/index.mjs

@@ -1,11 +1,80 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { memoize, makeExtendable, singleshot, getErrorMessage, not, trycatch, retry, Subject, randomString, errorData, ToolRegistry, isObject, sleep, resolveDocuments, str, queued } from 'functools-kit';
+import { errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, ToolRegistry, isObject, resolveDocuments, str, queued } from 'functools-kit';
 import fs, { mkdir, writeFile } from 'fs/promises';
 import path, { join } from 'path';
 import crypto from 'crypto';
 import os from 'os';
 
+const GLOBAL_CONFIG = {
+    /**
+     * Time to wait for scheduled signal to activate (in minutes)
+     * If signal does not activate within this time, it will be cancelled.
+     */
+    CC_SCHEDULE_AWAIT_MINUTES: 120,
+    /**
+     * Number of candles to use for average price calculation (VWAP)
+     * Default: 5 candles (last 5 minutes when using 1m interval)
+     */
+    CC_AVG_PRICE_CANDLES_COUNT: 5,
+    /**
+     * Minimum TakeProfit distance from priceOpen (percentage)
+     * Must be greater than trading fees to ensure profitable trades
+     * Default: 0.3% (covers 2×0.1% fees + minimum profit margin)
+     */
+    CC_MIN_TAKEPROFIT_DISTANCE_PERCENT: 0.1,
+    /**
+     * Maximum StopLoss distance from priceOpen (percentage)
+     * Prevents catastrophic losses from extreme StopLoss values
+     * Default: 20% (one signal cannot lose more than 20% of position)
+     */
+    CC_MAX_STOPLOSS_DISTANCE_PERCENT: 20,
+    /**
+     * Maximum signal lifetime in minutes
+     * Prevents eternal signals that block risk limits for weeks/months
+     * Default: 1440 minutes (1 day)
+     */
+    CC_MAX_SIGNAL_LIFETIME_MINUTES: 1440,
+    /**
+     * Number of retries for getCandles function
+     * Default: 3 retries
+     */
+    CC_GET_CANDLES_RETRY_COUNT: 3,
+    /**
+     * Delay between retries for getCandles function (in milliseconds)
+     * Default: 5000 ms (5 seconds)
+     */
+    CC_GET_CANDLES_RETRY_DELAY_MS: 5000,
+    /**
+     * Maximum allowed deviation factor for price anomaly detection.
+     * Price should not be more than this factor lower than reference price.
+     *
+     * Reasoning:
+     * - Incomplete candles from Binance API typically have prices near 0 (e.g., $0.01-1)
+     * - Normal BTC price ranges: $20,000-100,000
+     * - Factor 1000 catches prices below $20-100 when median is $20,000-100,000
+     * - Factor 100 would be too permissive (allows $200 when median is $20,000)
+     * - Factor 10000 might be too strict for low-cap altcoins
+     *
+     * Example: BTC at $50,000 median → threshold $50 (catches $0.01-1 anomalies)
+     */
+    CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR: 1000,
+    /**
+     * Minimum number of candles required for reliable median calculation.
+     * Below this threshold, use simple average instead of median.
+     *
+     * Reasoning:
+     * - Each candle provides 4 price points (OHLC)
+     * - 5 candles = 20 price points, sufficient for robust median calculation
+     * - Below 5 candles, single anomaly can heavily skew median
+     * - Statistical rule of thumb: minimum 7-10 data points for median stability
+     * - Average is more stable than median for small datasets (n < 20)
+     *
+     * Example: 3 candles = 12 points (use average), 5 candles = 20 points (use median)
+     */
+    CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN: 5,
+};
+
 const { init, inject, provide } = createActivator("backtest");
 
 /**
@@ -79,6 +148,7 @@ const logicPublicServices$1 = {
 const markdownServices$1 = {
     backtestMarkdownService: Symbol('backtestMarkdownService'),
     liveMarkdownService: Symbol('liveMarkdownService'),
+    scheduleMarkdownService: Symbol('scheduleMarkdownService'),
     performanceMarkdownService: Symbol('performanceMarkdownService'),
     walkerMarkdownService: Symbol('walkerMarkdownService'),
     heatMarkdownService: Symbol('heatMarkdownService'),
@@ -237,6 +307,92 @@ const INTERVAL_MINUTES$2 = {
     "6h": 360,
     "8h": 480,
 };
+/**
+ * Validates that all candles have valid OHLCV data without anomalies.
+ * Detects incomplete candles from Binance API by checking for abnormally low prices or volumes.
+ * Incomplete candles often have prices like 0.1 instead of normal 100,000 or zero volume.
+ *
+ * @param candles - Array of candle data to validate
+ * @throws Error if any candles have anomalous OHLCV values
+ */
+const VALIDATE_NO_INCOMPLETE_CANDLES_FN = (candles) => {
+    if (candles.length === 0) {
+        return;
+    }
+    // Calculate reference price (median or average depending on candle count)
+    const allPrices = candles.flatMap((c) => [c.open, c.high, c.low, c.close]);
+    const validPrices = allPrices.filter(p => p > 0);
+    let referencePrice;
+    if (candles.length >= GLOBAL_CONFIG.CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN) {
+        // Use median for reliable statistics with enough data
+        const sortedPrices = [...validPrices].sort((a, b) => a - b);
+        referencePrice = sortedPrices[Math.floor(sortedPrices.length / 2)] || 0;
+    }
+    else {
+        // Use average for small datasets (more stable than median)
+        const sum = validPrices.reduce((acc, p) => acc + p, 0);
+        referencePrice = validPrices.length > 0 ? sum / validPrices.length : 0;
+    }
+    if (referencePrice === 0) {
+        throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: cannot calculate reference price (all prices are zero)`);
+    }
+    const minValidPrice = referencePrice / GLOBAL_CONFIG.CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR;
+    for (let i = 0; i < candles.length; i++) {
+        const candle = candles[i];
+        // Check for invalid numeric values
+        if (!Number.isFinite(candle.open) ||
+            !Number.isFinite(candle.high) ||
+            !Number.isFinite(candle.low) ||
+            !Number.isFinite(candle.close) ||
+            !Number.isFinite(candle.volume) ||
+            !Number.isFinite(candle.timestamp)) {
+            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has invalid numeric values (NaN or Infinity)`);
+        }
+        // Check for negative values
+        if (candle.open <= 0 ||
+            candle.high <= 0 ||
+            candle.low <= 0 ||
+            candle.close <= 0 ||
+            candle.volume < 0) {
+            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has zero or negative values`);
+        }
+        // Check for anomalously low prices (incomplete candle indicator)
+        if (candle.open < minValidPrice ||
+            candle.high < minValidPrice ||
+            candle.low < minValidPrice ||
+            candle.close < minValidPrice) {
+            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has anomalously low price. ` +
+                `OHLC: [${candle.open}, ${candle.high}, ${candle.low}, ${candle.close}], ` +
+                `reference: ${referencePrice}, threshold: ${minValidPrice}`);
+        }
+    }
+};
+/**
+ * Retries the getCandles function with specified retry count and delay.
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param since - Date object representing the start time for fetching candles
+ * @param self - Instance of ClientExchange
+ * @returns Promise resolving to array of candle data
+ */
+const GET_CANDLES_FN = async (dto, since, self) => {
+    let lastError;
+    for (let i = 0; i !== GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_COUNT; i++) {
+        try {
+            const result = await self.params.getCandles(dto.symbol, dto.interval, since, dto.limit);
+            VALIDATE_NO_INCOMPLETE_CANDLES_FN(result);
+            return result;
+        }
+        catch (err) {
+            self.params.logger.warn(`ClientExchange GET_CANDLES_FN: attempt ${i + 1} failed for symbol=${dto.symbol}, interval=${dto.interval}, since=${since.toISOString()}, limit=${dto.limit}}`, {
+                error: errorData(err),
+                message: getErrorMessage(err),
+            });
+            lastError = err;
+            await sleep(GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS);
+        }
+    }
+    throw lastError;
+};
 /**
  * Client implementation for exchange data access.
  *
@@ -287,7 +443,7 @@ class ClientExchange {
             throw new Error(`ClientExchange unknown time adjust for interval=${interval}`);
         }
         const since = new Date(this.params.execution.context.when.getTime() - adjust * 60 * 1000);
-        const data = await this.params.getCandles(symbol, interval, since, limit);
+        const data = await GET_CANDLES_FN({ symbol, interval, limit }, since, this);
         // Filter candles to strictly match the requested range
         const whenTimestamp = this.params.execution.context.when.getTime();
         const sinceTimestamp = since.getTime();
@@ -325,7 +481,7 @@ class ClientExchange {
         if (endTime > now) {
             return [];
         }
-        const data = await this.params.getCandles(symbol, interval, since, limit);
+        const data = await GET_CANDLES_FN({ symbol, interval, limit }, since, this);
         // Filter candles to strictly match the requested range
         const sinceTimestamp = since.getTime();
         const filteredData = data.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp <= endTime);
@@ -338,7 +494,8 @@ class ClientExchange {
         return filteredData;
     }
     /**
-     * Calculates VWAP (Volume Weighted Average Price) from last 5 1m candles.
+     * Calculates VWAP (Volume Weighted Average Price) from last N 1m candles.
+     * The number of candles is configurable via GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT.
      *
      * Formula:
      * - Typical Price = (high + low + close) / 3
@@ -354,7 +511,7 @@ class ClientExchange {
         this.params.logger.debug(`ClientExchange getAveragePrice`, {
             symbol,
         });
-        const candles = await this.getCandles(symbol, "1m", 5);
+        const candles = await this.getCandles(symbol, "1m", GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT);
         if (candles.length === 0) {
             throw new Error(`ClientExchange getAveragePrice: no candles data for symbol=${symbol}`);
         }
@@ -1091,7 +1248,7 @@ class PersistSignalUtils {
      *   async readValue(id) { return JSON.parse(await redis.get(id)); }
      *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
      * }
-     * PersistSignalAdaper.usePersistSignalAdapter(RedisPersist);
+     * PersistSignalAdapter.usePersistSignalAdapter(RedisPersist);
      * ```
      */
     usePersistSignalAdapter(Ctor) {
@@ -1106,16 +1263,16 @@ class PersistSignalUtils {
  * @example
  * ```typescript
  * // Custom adapter
- * PersistSignalAdaper.usePersistSignalAdapter(RedisPersist);
+ * PersistSignalAdapter.usePersistSignalAdapter(RedisPersist);
  *
  * // Read signal
- * const signal = await PersistSignalAdaper.readSignalData("my-strategy", "BTCUSDT");
+ * const signal = await PersistSignalAdapter.readSignalData("my-strategy", "BTCUSDT");
  *
  * // Write signal
- * await PersistSignalAdaper.writeSignalData(signal, "my-strategy", "BTCUSDT");
+ * await PersistSignalAdapter.writeSignalData(signal, "my-strategy", "BTCUSDT");
  * ```
  */
-const PersistSignalAdaper = new PersistSignalUtils();
+const PersistSignalAdapter = new PersistSignalUtils();
 const PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER = "PersistRiskUtils.usePersistRiskAdapter";
 const PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA = "PersistRiskUtils.readPositionData";
 const PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA = "PersistRiskUtils.writePositionData";
@@ -1300,14 +1457,24 @@ const INTERVAL_MINUTES$1 = {
 };
 const VALIDATE_SIGNAL_FN = (signal) => {
     const errors = [];
-    // Валидация цен
-    if (signal.priceOpen <= 0) {
+    // ЗАЩИТА ОТ NaN/Infinity: все цены должны быть конечными числами
+    if (!isFinite(signal.priceOpen)) {
+        errors.push(`priceOpen must be a finite number, got ${signal.priceOpen} (${typeof signal.priceOpen})`);
+    }
+    if (!isFinite(signal.priceTakeProfit)) {
+        errors.push(`priceTakeProfit must be a finite number, got ${signal.priceTakeProfit} (${typeof signal.priceTakeProfit})`);
+    }
+    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 (signal.priceTakeProfit <= 0) {
+    if (isFinite(signal.priceTakeProfit) && signal.priceTakeProfit <= 0) {
         errors.push(`priceTakeProfit must be positive, got ${signal.priceTakeProfit}`);
     }
-    if (signal.priceStopLoss <= 0) {
+    if (isFinite(signal.priceStopLoss) && signal.priceStopLoss <= 0) {
         errors.push(`priceStopLoss must be positive, got ${signal.priceStopLoss}`);
     }
     // Валидация для long позиции
@@ -1318,6 +1485,24 @@ const VALIDATE_SIGNAL_FN = (signal) => {
         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_MAX_STOPLOSS_DISTANCE_PERCENT && 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") {
@@ -1327,13 +1512,44 @@ const VALIDATE_SIGNAL_FN = (signal) => {
         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_MAX_STOPLOSS_DISTANCE_PERCENT && 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 (signal.minuteEstimatedTime <= 0) {
         errors.push(`minuteEstimatedTime must be positive, got ${signal.minuteEstimatedTime}`);
     }
-    if (signal.timestamp <= 0) {
-        errors.push(`timestamp must be positive, got ${signal.timestamp}`);
+    // ЗАЩИТА ОТ ВЕЧНЫХ СИГНАЛОВ: ограничиваем максимальное время жизни сигнала
+    if (GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES && GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES) {
+        if (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 (signal.scheduledAt <= 0) {
+        errors.push(`scheduledAt must be positive, got ${signal.scheduledAt}`);
+    }
+    if (signal.pendingAt <= 0) {
+        errors.push(`pendingAt must be positive, got ${signal.pendingAt}`);
     }
     // Кидаем ошибку если есть проблемы
     if (errors.length > 0) {
@@ -1369,6 +1585,27 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
     if (!signal) {
         return null;
     }
+    // Если priceOpen указан - создаем scheduled signal (risk check при активации)
+    if (signal.priceOpen !== undefined) {
+        const scheduledSignalRow = {
+            id: randomString(),
+            priceOpen: signal.priceOpen,
+            position: signal.position,
+            note: signal.note,
+            priceTakeProfit: signal.priceTakeProfit,
+            priceStopLoss: signal.priceStopLoss,
+            minuteEstimatedTime: signal.minuteEstimatedTime,
+            symbol: self.params.execution.context.symbol,
+            exchangeName: self.params.method.context.exchangeName,
+            strategyName: self.params.method.context.strategyName,
+            scheduledAt: currentTime,
+            pendingAt: currentTime, // Временно, обновится при активации
+            _isScheduled: true,
+        };
+        // Валидируем сигнал перед возвратом
+        VALIDATE_SIGNAL_FN(scheduledSignalRow);
+        return scheduledSignalRow;
+    }
     const signalRow = {
         id: randomString(),
         priceOpen: currentPrice,
@@ -1376,7 +1613,9 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         symbol: self.params.execution.context.symbol,
         exchangeName: self.params.method.context.exchangeName,
         strategyName: self.params.method.context.strategyName,
-        timestamp: currentTime,
+        scheduledAt: currentTime,
+        pendingAt: currentTime, // Для immediate signal оба времени одинаковые
+        _isScheduled: false,
     };
     // Валидируем сигнал перед возвратом
     VALIDATE_SIGNAL_FN(signalRow);
@@ -1406,7 +1645,7 @@ const WAIT_FOR_INIT_FN$1 = async (self) => {
     if (self.params.execution.context.backtest) {
         return;
     }
-    const pendingSignal = await PersistSignalAdaper.readSignalData(self.params.strategyName, self.params.execution.context.symbol);
+    const pendingSignal = await PersistSignalAdapter.readSignalData(self.params.strategyName, self.params.execution.context.symbol);
     if (!pendingSignal) {
         return;
     }
@@ -1417,6 +1656,563 @@ const WAIT_FOR_INIT_FN$1 = async (self) => {
         return;
     }
     self._pendingSignal = pendingSignal;
+    // Call onActive callback for restored signal
+    if (self.params.callbacks?.onActive) {
+        const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
+        self.params.callbacks.onActive(self.params.execution.context.symbol, pendingSignal, currentPrice, self.params.execution.context.backtest);
+    }
+};
+const CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN = async (self, scheduled, currentPrice) => {
+    const currentTime = self.params.execution.context.when.getTime();
+    const signalTime = scheduled.scheduledAt; // Таймаут для scheduled signal считается от scheduledAt
+    const maxTimeToWait = GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES * 60 * 1000;
+    const elapsedTime = currentTime - signalTime;
+    if (elapsedTime < maxTimeToWait) {
+        return null;
+    }
+    self.params.logger.info("ClientStrategy scheduled signal cancelled by timeout", {
+        symbol: self.params.execution.context.symbol,
+        signalId: scheduled.id,
+        elapsedMinutes: Math.floor(elapsedTime / 60000),
+        maxMinutes: GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES,
+    });
+    self._scheduledSignal = null;
+    if (self.params.callbacks?.onCancel) {
+        self.params.callbacks.onCancel(self.params.execution.context.symbol, scheduled, currentPrice, self.params.execution.context.backtest);
+    }
+    const result = {
+        action: "cancelled",
+        signal: scheduled,
+        currentPrice: currentPrice,
+        closeTimestamp: currentTime,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        symbol: self.params.execution.context.symbol,
+    };
+    if (self.params.callbacks?.onTick) {
+        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
+    }
+    return result;
+};
+const CHECK_SCHEDULED_SIGNAL_PRICE_ACTIVATION_FN = (scheduled, currentPrice) => {
+    let shouldActivate = false;
+    let shouldCancel = false;
+    if (scheduled.position === "long") {
+        // КРИТИЧНО: Сначала проверяем StopLoss (отмена приоритетнее активации)
+        // Отмена если цена упала СЛИШКОМ низко (ниже SL)
+        if (currentPrice <= scheduled.priceStopLoss) {
+            shouldCancel = true;
+        }
+        // Long = покупаем дешевле, ждем падения цены ДО priceOpen
+        // Активируем только если НЕ пробит StopLoss
+        else if (currentPrice <= scheduled.priceOpen) {
+            shouldActivate = true;
+        }
+    }
+    if (scheduled.position === "short") {
+        // КРИТИЧНО: Сначала проверяем StopLoss (отмена приоритетнее активации)
+        // Отмена если цена выросла СЛИШКОМ высоко (выше SL)
+        if (currentPrice >= scheduled.priceStopLoss) {
+            shouldCancel = true;
+        }
+        // Short = продаем дороже, ждем роста цены ДО priceOpen
+        // Активируем только если НЕ пробит StopLoss
+        else if (currentPrice >= scheduled.priceOpen) {
+            shouldActivate = true;
+        }
+    }
+    return { shouldActivate, shouldCancel };
+};
+const CANCEL_SCHEDULED_SIGNAL_BY_STOPLOSS_FN = async (self, scheduled, currentPrice) => {
+    self.params.logger.info("ClientStrategy scheduled signal cancelled", {
+        symbol: self.params.execution.context.symbol,
+        signalId: scheduled.id,
+        position: scheduled.position,
+        averagePrice: currentPrice,
+        priceStopLoss: scheduled.priceStopLoss,
+    });
+    self._scheduledSignal = null;
+    const result = {
+        action: "idle",
+        signal: null,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        symbol: self.params.execution.context.symbol,
+        currentPrice: currentPrice,
+    };
+    if (self.params.callbacks?.onTick) {
+        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
+    }
+    return result;
+};
+const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp) => {
+    // Check if strategy was stopped
+    if (self._isStopped) {
+        self.params.logger.info("ClientStrategy scheduled signal activation cancelled (stopped)", {
+            symbol: self.params.execution.context.symbol,
+            signalId: scheduled.id,
+        });
+        self._scheduledSignal = null;
+        return null;
+    }
+    // В LIVE режиме activationTimestamp - это текущее время при tick()
+    // В отличие от BACKTEST (где используется candle.timestamp + 60s),
+    // здесь мы не знаем ТОЧНОЕ время достижения priceOpen,
+    // поэтому используем время обнаружения активации
+    const activationTime = activationTimestamp;
+    self.params.logger.info("ClientStrategy scheduled signal activation begin", {
+        symbol: self.params.execution.context.symbol,
+        signalId: scheduled.id,
+        position: scheduled.position,
+        averagePrice: scheduled.priceOpen,
+        priceOpen: scheduled.priceOpen,
+        scheduledAt: scheduled.scheduledAt,
+        pendingAt: activationTime,
+    });
+    if (await not(self.params.risk.checkSignal({
+        symbol: self.params.execution.context.symbol,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        currentPrice: scheduled.priceOpen,
+        timestamp: activationTime,
+    }))) {
+        self.params.logger.info("ClientStrategy scheduled signal rejected by risk", {
+            symbol: self.params.execution.context.symbol,
+            signalId: scheduled.id,
+        });
+        self._scheduledSignal = null;
+        return null;
+    }
+    self._scheduledSignal = null;
+    // КРИТИЧЕСКИ ВАЖНО: обновляем pendingAt при активации
+    const activatedSignal = {
+        ...scheduled,
+        pendingAt: activationTime,
+        _isScheduled: false,
+    };
+    await self.setPendingSignal(activatedSignal);
+    await self.params.risk.addSignal(self.params.execution.context.symbol, {
+        strategyName: self.params.method.context.strategyName,
+        riskName: self.params.riskName,
+    });
+    if (self.params.callbacks?.onOpen) {
+        self.params.callbacks.onOpen(self.params.execution.context.symbol, self._pendingSignal, self._pendingSignal.priceOpen, self.params.execution.context.backtest);
+    }
+    const result = {
+        action: "opened",
+        signal: self._pendingSignal,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        symbol: self.params.execution.context.symbol,
+        currentPrice: self._pendingSignal.priceOpen,
+    };
+    if (self.params.callbacks?.onTick) {
+        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
+    }
+    return result;
+};
+const RETURN_SCHEDULED_SIGNAL_ACTIVE_FN = async (self, scheduled, currentPrice) => {
+    const result = {
+        action: "active",
+        signal: scheduled,
+        currentPrice: currentPrice,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        symbol: self.params.execution.context.symbol,
+    };
+    if (self.params.callbacks?.onTick) {
+        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
+    }
+    return result;
+};
+const OPEN_NEW_SCHEDULED_SIGNAL_FN = async (self, signal) => {
+    const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
+    self.params.logger.info("ClientStrategy scheduled signal created", {
+        symbol: self.params.execution.context.symbol,
+        signalId: signal.id,
+        position: signal.position,
+        priceOpen: signal.priceOpen,
+        currentPrice: currentPrice,
+    });
+    if (self.params.callbacks?.onSchedule) {
+        self.params.callbacks.onSchedule(self.params.execution.context.symbol, signal, currentPrice, self.params.execution.context.backtest);
+    }
+    const result = {
+        action: "scheduled",
+        signal: signal,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        symbol: self.params.execution.context.symbol,
+        currentPrice: currentPrice,
+    };
+    if (self.params.callbacks?.onTick) {
+        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
+    }
+    return result;
+};
+const OPEN_NEW_PENDING_SIGNAL_FN = async (self, signal) => {
+    if (await not(self.params.risk.checkSignal({
+        symbol: self.params.execution.context.symbol,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        currentPrice: signal.priceOpen,
+        timestamp: self.params.execution.context.when.getTime(),
+    }))) {
+        return null;
+    }
+    await self.params.risk.addSignal(self.params.execution.context.symbol, {
+        strategyName: self.params.method.context.strategyName,
+        riskName: self.params.riskName,
+    });
+    if (self.params.callbacks?.onOpen) {
+        self.params.callbacks.onOpen(self.params.execution.context.symbol, signal, signal.priceOpen, self.params.execution.context.backtest);
+    }
+    const result = {
+        action: "opened",
+        signal: signal,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        symbol: self.params.execution.context.symbol,
+        currentPrice: signal.priceOpen,
+    };
+    if (self.params.callbacks?.onTick) {
+        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
+    }
+    return result;
+};
+const CHECK_PENDING_SIGNAL_COMPLETION_FN = async (self, signal, averagePrice) => {
+    const currentTime = self.params.execution.context.when.getTime();
+    const signalTime = signal.pendingAt; // КРИТИЧНО: используем pendingAt, а не scheduledAt!
+    const maxTimeToWait = signal.minuteEstimatedTime * 60 * 1000;
+    const elapsedTime = currentTime - signalTime;
+    // Check time expiration
+    if (elapsedTime >= maxTimeToWait) {
+        return await CLOSE_PENDING_SIGNAL_FN(self, signal, averagePrice, "time_expired");
+    }
+    // Check take profit
+    if (signal.position === "long" && averagePrice >= signal.priceTakeProfit) {
+        return await CLOSE_PENDING_SIGNAL_FN(self, signal, signal.priceTakeProfit, // КРИТИЧНО: используем точную цену TP
+        "take_profit");
+    }
+    if (signal.position === "short" && averagePrice <= signal.priceTakeProfit) {
+        return await CLOSE_PENDING_SIGNAL_FN(self, signal, signal.priceTakeProfit, // КРИТИЧНО: используем точную цену TP
+        "take_profit");
+    }
+    // Check stop loss
+    if (signal.position === "long" && averagePrice <= signal.priceStopLoss) {
+        return await CLOSE_PENDING_SIGNAL_FN(self, signal, signal.priceStopLoss, // КРИТИЧНО: используем точную цену SL
+        "stop_loss");
+    }
+    if (signal.position === "short" && averagePrice >= signal.priceStopLoss) {
+        return await CLOSE_PENDING_SIGNAL_FN(self, signal, signal.priceStopLoss, // КРИТИЧНО: используем точную цену SL
+        "stop_loss");
+    }
+    return null;
+};
+const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason) => {
+    const pnl = toProfitLossDto(signal, currentPrice);
+    self.params.logger.info(`ClientStrategy signal ${closeReason}`, {
+        symbol: self.params.execution.context.symbol,
+        signalId: signal.id,
+        closeReason,
+        priceClose: currentPrice,
+        pnlPercentage: pnl.pnlPercentage,
+    });
+    if (self.params.callbacks?.onClose) {
+        self.params.callbacks.onClose(self.params.execution.context.symbol, signal, currentPrice, self.params.execution.context.backtest);
+    }
+    await self.params.risk.removeSignal(self.params.execution.context.symbol, {
+        strategyName: self.params.method.context.strategyName,
+        riskName: self.params.riskName,
+    });
+    await self.setPendingSignal(null);
+    const result = {
+        action: "closed",
+        signal: signal,
+        currentPrice: currentPrice,
+        closeReason: closeReason,
+        closeTimestamp: self.params.execution.context.when.getTime(),
+        pnl: pnl,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        symbol: self.params.execution.context.symbol,
+    };
+    if (self.params.callbacks?.onTick) {
+        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
+    }
+    return result;
+};
+const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
+    const result = {
+        action: "active",
+        signal: signal,
+        currentPrice: currentPrice,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        symbol: self.params.execution.context.symbol,
+    };
+    if (self.params.callbacks?.onTick) {
+        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
+    }
+    return result;
+};
+const RETURN_IDLE_FN = async (self, currentPrice) => {
+    if (self.params.callbacks?.onIdle) {
+        self.params.callbacks.onIdle(self.params.execution.context.symbol, currentPrice, self.params.execution.context.backtest);
+    }
+    const result = {
+        action: "idle",
+        signal: null,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        symbol: self.params.execution.context.symbol,
+        currentPrice: currentPrice,
+    };
+    if (self.params.callbacks?.onTick) {
+        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
+    }
+    return result;
+};
+const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePrice, closeTimestamp) => {
+    self.params.logger.info("ClientStrategy backtest scheduled signal cancelled", {
+        symbol: self.params.execution.context.symbol,
+        signalId: scheduled.id,
+        closeTimestamp,
+        averagePrice,
+        priceStopLoss: scheduled.priceStopLoss,
+    });
+    self._scheduledSignal = null;
+    if (self.params.callbacks?.onCancel) {
+        self.params.callbacks.onCancel(self.params.execution.context.symbol, scheduled, averagePrice, self.params.execution.context.backtest);
+    }
+    const result = {
+        action: "cancelled",
+        signal: scheduled,
+        currentPrice: averagePrice,
+        closeTimestamp: closeTimestamp,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        symbol: self.params.execution.context.symbol,
+    };
+    if (self.params.callbacks?.onTick) {
+        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
+    }
+    return result;
+};
+const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activationTimestamp) => {
+    // Check if strategy was stopped
+    if (self._isStopped) {
+        self.params.logger.info("ClientStrategy backtest scheduled signal activation cancelled (stopped)", {
+            symbol: self.params.execution.context.symbol,
+            signalId: scheduled.id,
+        });
+        self._scheduledSignal = null;
+        return false;
+    }
+    // В BACKTEST режиме activationTimestamp - это candle.timestamp + 60*1000
+    // (timestamp СЛЕДУЮЩЕЙ свечи после достижения priceOpen)
+    // Это обеспечивает точный расчёт minuteEstimatedTime от момента активации
+    const activationTime = activationTimestamp;
+    self.params.logger.info("ClientStrategy backtest scheduled signal activated", {
+        symbol: self.params.execution.context.symbol,
+        signalId: scheduled.id,
+        priceOpen: scheduled.priceOpen,
+        scheduledAt: scheduled.scheduledAt,
+        pendingAt: activationTime,
+    });
+    if (await not(self.params.risk.checkSignal({
+        symbol: self.params.execution.context.symbol,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        currentPrice: scheduled.priceOpen,
+        timestamp: activationTime,
+    }))) {
+        self.params.logger.info("ClientStrategy backtest scheduled signal rejected by risk", {
+            symbol: self.params.execution.context.symbol,
+            signalId: scheduled.id,
+        });
+        self._scheduledSignal = null;
+        return false;
+    }
+    self._scheduledSignal = null;
+    // КРИТИЧЕСКИ ВАЖНО: обновляем pendingAt при активации в backtest
+    const activatedSignal = {
+        ...scheduled,
+        pendingAt: activationTime,
+        _isScheduled: false,
+    };
+    await self.setPendingSignal(activatedSignal);
+    await self.params.risk.addSignal(self.params.execution.context.symbol, {
+        strategyName: self.params.method.context.strategyName,
+        riskName: self.params.riskName,
+    });
+    if (self.params.callbacks?.onOpen) {
+        self.params.callbacks.onOpen(self.params.execution.context.symbol, activatedSignal, activatedSignal.priceOpen, self.params.execution.context.backtest);
+    }
+    return true;
+};
+const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, closeReason, closeTimestamp) => {
+    const pnl = toProfitLossDto(signal, averagePrice);
+    self.params.logger.debug(`ClientStrategy backtest ${closeReason}`, {
+        symbol: self.params.execution.context.symbol,
+        signalId: signal.id,
+        reason: closeReason,
+        priceClose: averagePrice,
+        closeTimestamp,
+        pnlPercentage: pnl.pnlPercentage,
+    });
+    if (closeReason === "stop_loss") {
+        self.params.logger.warn(`ClientStrategy backtest: Signal closed with loss (stop_loss), PNL: ${pnl.pnlPercentage.toFixed(2)}%`);
+    }
+    if (closeReason === "time_expired" && pnl.pnlPercentage < 0) {
+        self.params.logger.warn(`ClientStrategy backtest: Signal closed with loss (time_expired), PNL: ${pnl.pnlPercentage.toFixed(2)}%`);
+    }
+    if (self.params.callbacks?.onClose) {
+        self.params.callbacks.onClose(self.params.execution.context.symbol, signal, averagePrice, self.params.execution.context.backtest);
+    }
+    await self.params.risk.removeSignal(self.params.execution.context.symbol, {
+        strategyName: self.params.method.context.strategyName,
+        riskName: self.params.riskName,
+    });
+    await self.setPendingSignal(null);
+    const result = {
+        action: "closed",
+        signal: signal,
+        currentPrice: averagePrice,
+        closeReason: closeReason,
+        closeTimestamp: closeTimestamp,
+        pnl: pnl,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        symbol: self.params.execution.context.symbol,
+    };
+    if (self.params.callbacks?.onTick) {
+        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
+    }
+    return result;
+};
+const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) => {
+    const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
+    const maxTimeToWait = GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES * 60 * 1000;
+    for (let i = 0; i < candles.length; i++) {
+        const candle = candles[i];
+        const recentCandles = candles.slice(Math.max(0, i - (candlesCount - 1)), i + 1);
+        const averagePrice = GET_AVG_PRICE_FN(recentCandles);
+        // КРИТИЧНО: Проверяем timeout ПЕРЕД проверкой цены
+        const elapsedTime = candle.timestamp - scheduled.scheduledAt;
+        if (elapsedTime >= maxTimeToWait) {
+            const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp);
+            return { activated: false, cancelled: true, activationIndex: i, result };
+        }
+        let shouldActivate = false;
+        let shouldCancel = false;
+        if (scheduled.position === "long") {
+            // КРИТИЧНО для LONG:
+            // - priceOpen > priceStopLoss (по валидации)
+            // - Активация: low <= priceOpen (цена упала до входа)
+            // - Отмена: low <= priceStopLoss (цена пробила SL)
+            //
+            // EDGE CASE: если low <= priceStopLoss И low <= priceOpen на ОДНОЙ свече:
+            // => Отмена имеет ПРИОРИТЕТ! (SL пробит ДО или ВМЕСТЕ с активацией)
+            // Сигнал НЕ открывается, сразу отменяется
+            if (candle.low <= scheduled.priceStopLoss) {
+                shouldCancel = true;
+            }
+            else if (candle.low <= scheduled.priceOpen) {
+                shouldActivate = true;
+            }
+        }
+        if (scheduled.position === "short") {
+            // КРИТИЧНО для SHORT:
+            // - priceOpen < priceStopLoss (по валидации)
+            // - Активация: high >= priceOpen (цена выросла до входа)
+            // - Отмена: high >= priceStopLoss (цена пробила SL)
+            //
+            // EDGE CASE: если high >= priceStopLoss И high >= priceOpen на ОДНОЙ свече:
+            // => Отмена имеет ПРИОРИТЕТ! (SL пробит ДО или ВМЕСТЕ с активацией)
+            // Сигнал НЕ открывается, сразу отменяется
+            if (candle.high >= scheduled.priceStopLoss) {
+                shouldCancel = true;
+            }
+            else if (candle.high >= scheduled.priceOpen) {
+                shouldActivate = true;
+            }
+        }
+        if (shouldCancel) {
+            const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp);
+            return { activated: false, cancelled: true, activationIndex: i, result };
+        }
+        if (shouldActivate) {
+            await ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, candle.timestamp);
+            return {
+                activated: true,
+                cancelled: false,
+                activationIndex: i,
+                result: null,
+            };
+        }
+    }
+    return {
+        activated: false,
+        cancelled: false,
+        activationIndex: -1,
+        result: null,
+    };
+};
+const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
+    const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
+    for (let i = candlesCount - 1; i < candles.length; i++) {
+        const recentCandles = candles.slice(i - (candlesCount - 1), i + 1);
+        const averagePrice = GET_AVG_PRICE_FN(recentCandles);
+        const currentCandleTimestamp = recentCandles[recentCandles.length - 1].timestamp;
+        const currentCandle = recentCandles[recentCandles.length - 1];
+        let shouldClose = false;
+        let closeReason;
+        // Check time expiration FIRST (КРИТИЧНО!)
+        const signalTime = signal.pendingAt;
+        const maxTimeToWait = signal.minuteEstimatedTime * 60 * 1000;
+        const elapsedTime = currentCandleTimestamp - signalTime;
+        if (elapsedTime >= maxTimeToWait) {
+            shouldClose = true;
+            closeReason = "time_expired";
+        }
+        // Check TP/SL only if not expired
+        // КРИТИЧНО: используем candle.high/low для точной проверки достижения TP/SL
+        if (!shouldClose && signal.position === "long") {
+            // Для LONG: TP срабатывает если high >= TP, SL если low <= SL
+            if (currentCandle.high >= signal.priceTakeProfit) {
+                shouldClose = true;
+                closeReason = "take_profit";
+            }
+            else if (currentCandle.low <= signal.priceStopLoss) {
+                shouldClose = true;
+                closeReason = "stop_loss";
+            }
+        }
+        if (!shouldClose && signal.position === "short") {
+            // Для SHORT: TP срабатывает если low <= TP, SL если high >= SL
+            if (currentCandle.low <= signal.priceTakeProfit) {
+                shouldClose = true;
+                closeReason = "take_profit";
+            }
+            else if (currentCandle.high >= signal.priceStopLoss) {
+                shouldClose = true;
+                closeReason = "stop_loss";
+            }
+        }
+        if (shouldClose) {
+            // КРИТИЧНО: при закрытии по TP/SL используем точную цену, а не averagePrice
+            let closePrice = averagePrice;
+            if (closeReason === "take_profit") {
+                closePrice = signal.priceTakeProfit;
+            }
+            else if (closeReason === "stop_loss") {
+                closePrice = signal.priceStopLoss;
+            }
+            return await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(self, signal, closePrice, closeReason, currentCandleTimestamp);
+        }
+    }
+    return null;
 };
 /**
  * Client implementation for trading strategy lifecycle management.
@@ -1450,6 +2246,7 @@ class ClientStrategy {
         this.params = params;
         this._isStopped = false;
         this._pendingSignal = null;
+        this._scheduledSignal = null;
         this._lastSignalTimestamp = null;
         /**
          * Initializes strategy state by loading persisted signal from disk.
@@ -1476,22 +2273,34 @@ class ClientStrategy {
             pendingSignal,
         });
         this._pendingSignal = pendingSignal;
+        // КРИТИЧНО: Всегда вызываем коллбек onWrite для тестирования persist storage
+        // даже в backtest режиме, чтобы тесты могли перехватывать вызовы через mock adapter
+        if (this.params.callbacks?.onWrite) {
+            this.params.callbacks.onWrite(this.params.execution.context.symbol, this._pendingSignal, this.params.execution.context.backtest);
+        }
         if (this.params.execution.context.backtest) {
             return;
         }
-        await PersistSignalAdaper.writeSignalData(this._pendingSignal, this.params.strategyName, this.params.execution.context.symbol);
+        await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.strategyName, this.params.execution.context.symbol);
     }
     /**
      * Performs a single tick of strategy execution.
      *
-     * Flow:
-     * 1. If no pending signal: call getSignal with throttling and validation
-     * 2. If signal opened: trigger onOpen callback, persist state
-     * 3. If pending signal exists: check VWAP against TP/SL
-     * 4. If TP/SL/time reached: close signal, trigger onClose, persist state
+     * Flow (LIVE mode):
+     * 1. If scheduled signal exists: check activation/cancellation
+     * 2. If no pending/scheduled signal: call getSignal with throttling and validation
+     * 3. If signal opened: trigger onOpen callback, persist state
+     * 4. If pending signal exists: check VWAP against TP/SL
+     * 5. If TP/SL/time reached: close signal, trigger onClose, persist state
+     *
+     * Flow (BACKTEST mode):
+     * 1. If no pending/scheduled signal: call getSignal
+     * 2. If scheduled signal created: return "scheduled" (backtest() will handle it)
+     * 3. Otherwise same as LIVE
      *
      * @returns Promise resolving to discriminated union result:
      * - idle: No signal generated
+     * - scheduled: Scheduled signal created (backtest only)
      * - opened: New signal just created
      * - active: Signal monitoring in progress
      * - closed: Signal completed with PNL
@@ -1506,301 +2315,195 @@ class ClientStrategy {
      */
     async tick() {
         this.params.logger.debug("ClientStrategy tick");
-        if (!this._pendingSignal) {
-            const pendingSignal = await GET_SIGNAL_FN(this);
-            await this.setPendingSignal(pendingSignal);
-            if (this._pendingSignal) {
-                // Register signal with risk management
-                await this.params.risk.addSignal(this.params.execution.context.symbol, {
-                    strategyName: this.params.method.context.strategyName,
-                    riskName: this.params.riskName,
-                });
-                if (this.params.callbacks?.onOpen) {
-                    this.params.callbacks.onOpen(this.params.execution.context.symbol, this._pendingSignal, this._pendingSignal.priceOpen, this.params.execution.context.backtest);
-                }
-                const result = {
-                    action: "opened",
-                    signal: this._pendingSignal,
-                    strategyName: this.params.method.context.strategyName,
-                    exchangeName: this.params.method.context.exchangeName,
-                    symbol: this.params.execution.context.symbol,
-                    currentPrice: this._pendingSignal.priceOpen,
-                };
-                if (this.params.callbacks?.onTick) {
-                    this.params.callbacks.onTick(this.params.execution.context.symbol, result, this.params.execution.context.backtest);
-                }
-                return result;
-            }
+        // Получаем текущее время в начале tick для консистентности
+        const currentTime = this.params.execution.context.when.getTime();
+        // Early return if strategy was stopped
+        if (this._isStopped) {
             const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
-            if (this.params.callbacks?.onIdle) {
-                this.params.callbacks.onIdle(this.params.execution.context.symbol, currentPrice, this.params.execution.context.backtest);
-            }
-            const result = {
-                action: "idle",
-                signal: null,
-                strategyName: this.params.method.context.strategyName,
-                exchangeName: this.params.method.context.exchangeName,
-                symbol: this.params.execution.context.symbol,
-                currentPrice,
-            };
-            if (this.params.callbacks?.onTick) {
-                this.params.callbacks.onTick(this.params.execution.context.symbol, result, this.params.execution.context.backtest);
-            }
-            return result;
-        }
-        const when = this.params.execution.context.when;
-        const signal = this._pendingSignal;
-        // Получаем среднюю цену
-        const averagePrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
-        this.params.logger.debug("ClientStrategy tick check", {
-            symbol: this.params.execution.context.symbol,
-            averagePrice,
-            signalId: signal.id,
-            position: signal.position,
-        });
-        let shouldClose = false;
-        let closeReason;
-        // Проверяем истечение времени
-        const signalEndTime = signal.timestamp + signal.minuteEstimatedTime * 60 * 1000;
-        if (when.getTime() >= signalEndTime) {
-            shouldClose = true;
-            closeReason = "time_expired";
-        }
-        // Проверяем достижение TP/SL для long позиции
-        if (signal.position === "long") {
-            if (averagePrice >= signal.priceTakeProfit) {
-                shouldClose = true;
-                closeReason = "take_profit";
-            }
-            else if (averagePrice <= signal.priceStopLoss) {
-                shouldClose = true;
-                closeReason = "stop_loss";
-            }
+            return await RETURN_IDLE_FN(this, currentPrice);
         }
-        // Проверяем достижение TP/SL для short позиции
-        if (signal.position === "short") {
-            if (averagePrice <= signal.priceTakeProfit) {
-                shouldClose = true;
-                closeReason = "take_profit";
+        // Monitor scheduled signal
+        if (this._scheduledSignal && !this._pendingSignal) {
+            const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+            // Check timeout
+            const timeoutResult = await CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN(this, this._scheduledSignal, currentPrice);
+            if (timeoutResult)
+                return timeoutResult;
+            // Check price-based activation/cancellation
+            const { shouldActivate, shouldCancel } = CHECK_SCHEDULED_SIGNAL_PRICE_ACTIVATION_FN(this._scheduledSignal, currentPrice);
+            if (shouldCancel) {
+                return await CANCEL_SCHEDULED_SIGNAL_BY_STOPLOSS_FN(this, this._scheduledSignal, currentPrice);
             }
-            else if (averagePrice >= signal.priceStopLoss) {
-                shouldClose = true;
-                closeReason = "stop_loss";
+            if (shouldActivate) {
+                const activateResult = await ACTIVATE_SCHEDULED_SIGNAL_FN(this, this._scheduledSignal, currentTime);
+                if (activateResult) {
+                    return activateResult;
+                }
+                // Risk rejected or stopped - return idle
+                return await RETURN_IDLE_FN(this, currentPrice);
             }
+            return await RETURN_SCHEDULED_SIGNAL_ACTIVE_FN(this, this._scheduledSignal, currentPrice);
         }
-        // Закрываем сигнал если выполнены условия
-        if (shouldClose) {
-            const pnl = toProfitLossDto(signal, averagePrice);
-            const closeTimestamp = this.params.execution.context.when.getTime();
-            // Предупреждение о закрытии сигнала в убыток
-            if (closeReason === "stop_loss") {
-                this.params.logger.warn(`ClientStrategy tick: Signal closed with loss (stop_loss), PNL: ${pnl.pnlPercentage.toFixed(2)}%`);
-            }
-            // Предупреждение о закрытии сигнала в убыток
-            if (closeReason === "time_expired" && pnl.pnlPercentage < 0) {
-                this.params.logger.warn(`ClientStrategy tick: Signal closed with loss (time_expired), PNL: ${pnl.pnlPercentage.toFixed(2)}%`);
-            }
-            this.params.logger.debug("ClientStrategy closing", {
-                symbol: this.params.execution.context.symbol,
-                signalId: signal.id,
-                reason: closeReason,
-                priceClose: averagePrice,
-                closeTimestamp,
-                pnlPercentage: pnl.pnlPercentage,
-            });
-            if (this.params.callbacks?.onClose) {
-                this.params.callbacks.onClose(this.params.execution.context.symbol, signal, averagePrice, this.params.execution.context.backtest);
+        // Generate new signal if none exists
+        if (!this._pendingSignal && !this._scheduledSignal) {
+            const signal = await GET_SIGNAL_FN(this);
+            if (signal) {
+                if (signal._isScheduled === true) {
+                    this._scheduledSignal = signal;
+                    return await OPEN_NEW_SCHEDULED_SIGNAL_FN(this, this._scheduledSignal);
+                }
+                await this.setPendingSignal(signal);
             }
-            // Remove signal from risk management
-            await this.params.risk.removeSignal(this.params.execution.context.symbol, {
-                strategyName: this.params.method.context.strategyName,
-                riskName: this.params.riskName,
-            });
-            await this.setPendingSignal(null);
-            const result = {
-                action: "closed",
-                signal: signal,
-                currentPrice: averagePrice,
-                closeReason: closeReason,
-                closeTimestamp: closeTimestamp,
-                pnl: pnl,
-                strategyName: this.params.method.context.strategyName,
-                exchangeName: this.params.method.context.exchangeName,
-                symbol: this.params.execution.context.symbol,
-            };
-            if (this.params.callbacks?.onTick) {
-                this.params.callbacks.onTick(this.params.execution.context.symbol, result, this.params.execution.context.backtest);
+            if (this._pendingSignal) {
+                const openResult = await OPEN_NEW_PENDING_SIGNAL_FN(this, this._pendingSignal);
+                if (openResult) {
+                    return openResult;
+                }
+                // Risk rejected - clear pending signal and return idle
+                await this.setPendingSignal(null);
             }
-            return result;
-        }
-        if (this.params.callbacks?.onActive) {
-            this.params.callbacks.onActive(this.params.execution.context.symbol, signal, averagePrice, this.params.execution.context.backtest);
+            const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+            return await RETURN_IDLE_FN(this, currentPrice);
         }
-        const result = {
-            action: "active",
-            signal: signal,
-            currentPrice: averagePrice,
-            strategyName: this.params.method.context.strategyName,
-            exchangeName: this.params.method.context.exchangeName,
-            symbol: this.params.execution.context.symbol,
-        };
-        if (this.params.callbacks?.onTick) {
-            this.params.callbacks.onTick(this.params.execution.context.symbol, result, this.params.execution.context.backtest);
+        // Monitor pending signal
+        const averagePrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+        const closedResult = await CHECK_PENDING_SIGNAL_COMPLETION_FN(this, this._pendingSignal, averagePrice);
+        if (closedResult) {
+            return closedResult;
         }
-        return result;
+        return await RETURN_PENDING_SIGNAL_ACTIVE_FN(this, this._pendingSignal, averagePrice);
     }
     /**
-     * Fast backtests a pending signal using historical candle data.
+     * Fast backtests a signal using historical candle data.
+     *
+     * For scheduled signals:
+     * 1. Iterates through candles checking for activation (price reaches priceOpen)
+     * 2. Or cancellation (price hits StopLoss before activation)
+     * 3. If activated: converts to pending signal and continues with TP/SL monitoring
+     * 4. If cancelled: returns closed result with closeReason "cancelled"
      *
-     * Iterates through candles checking VWAP against TP/SL on each timeframe.
-     * Starts from index 4 (needs 5 candles for VWAP calculation).
-     * Always returns closed result (either TP/SL or time_expired).
+     * For pending signals:
+     * 1. Iterates through candles checking VWAP against TP/SL on each timeframe
+     * 2. Starts from index 4 (needs 5 candles for VWAP calculation)
+     * 3. Returns closed result (either TP/SL or time_expired)
      *
-     * @param candles - Array of candles covering signal's minuteEstimatedTime
+     * @param candles - Array of candles to process
      * @returns Promise resolving to closed signal result with PNL
-     * @throws Error if no pending signal or not in backtest mode
+     * @throws Error if no pending/scheduled signal or not in backtest mode
      *
      * @example
      * ```typescript
      * // After signal opened in backtest
      * const candles = await exchange.getNextCandles("BTCUSDT", "1m", signal.minuteEstimatedTime);
      * const result = await strategy.backtest(candles);
-     * console.log(result.closeReason); // "take_profit" | "stop_loss" | "time_expired"
+     * console.log(result.closeReason); // "take_profit" | "stop_loss" | "time_expired" | "cancelled"
      * ```
      */
     async backtest(candles) {
         this.params.logger.debug("ClientStrategy backtest", {
             symbol: this.params.execution.context.symbol,
             candlesCount: candles.length,
+            hasScheduled: !!this._scheduledSignal,
+            hasPending: !!this._pendingSignal,
         });
-        const signal = this._pendingSignal;
-        if (!signal) {
-            throw new Error("ClientStrategy backtest: no pending signal");
-        }
         if (!this.params.execution.context.backtest) {
             throw new Error("ClientStrategy backtest: running in live context");
         }
-        // Предупреждение если недостаточно свечей для VWAP
-        if (candles.length < 5) {
-            this.params.logger.warn(`ClientStrategy backtest: Expected at least 5 candles for VWAP, got ${candles.length}`);
-        }
-        // Проверяем каждую свечу на достижение TP/SL
-        // Начинаем с индекса 4 (пятая свеча), чтобы было минимум 5 свечей для VWAP
-        for (let i = 4; i < candles.length; i++) {
-            // Вычисляем VWAP из последних 5 свечей для текущего момента
-            const recentCandles = candles.slice(i - 4, i + 1);
-            const averagePrice = GET_AVG_PRICE_FN(recentCandles);
-            let shouldClose = false;
-            let closeReason;
-            // Проверяем достижение TP/SL для long позиции
-            if (signal.position === "long") {
-                if (averagePrice >= signal.priceTakeProfit) {
-                    shouldClose = true;
-                    closeReason = "take_profit";
-                }
-                else if (averagePrice <= signal.priceStopLoss) {
-                    shouldClose = true;
-                    closeReason = "stop_loss";
-                }
+        if (!this._pendingSignal && !this._scheduledSignal) {
+            throw new Error("ClientStrategy backtest: no pending or scheduled signal");
+        }
+        // Process scheduled signal
+        if (this._scheduledSignal && !this._pendingSignal) {
+            const scheduled = this._scheduledSignal;
+            this.params.logger.debug("ClientStrategy backtest scheduled signal", {
+                symbol: this.params.execution.context.symbol,
+                signalId: scheduled.id,
+                priceOpen: scheduled.priceOpen,
+                position: scheduled.position,
+            });
+            const { activated, cancelled, activationIndex, result } = await PROCESS_SCHEDULED_SIGNAL_CANDLES_FN(this, scheduled, candles);
+            if (cancelled && result) {
+                return result;
             }
-            // Проверяем достижение TP/SL для short позиции
-            if (signal.position === "short") {
-                if (averagePrice <= signal.priceTakeProfit) {
-                    shouldClose = true;
-                    closeReason = "take_profit";
-                }
-                else if (averagePrice >= signal.priceStopLoss) {
-                    shouldClose = true;
-                    closeReason = "stop_loss";
+            if (activated) {
+                const remainingCandles = candles.slice(activationIndex + 1);
+                if (remainingCandles.length === 0) {
+                    const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
+                    const recentCandles = candles.slice(Math.max(0, activationIndex - (candlesCount - 1)), activationIndex + 1);
+                    const lastPrice = GET_AVG_PRICE_FN(recentCandles);
+                    const closeTimestamp = candles[activationIndex].timestamp;
+                    return await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(this, scheduled, lastPrice, "time_expired", closeTimestamp);
                 }
+                candles = remainingCandles;
             }
-            // Если достигнут TP/SL, закрываем сигнал
-            if (shouldClose) {
-                const pnl = toProfitLossDto(signal, averagePrice);
-                const closeTimestamp = recentCandles[recentCandles.length - 1].timestamp;
-                this.params.logger.debug("ClientStrategy backtest closing", {
-                    symbol: this.params.execution.context.symbol,
-                    signalId: signal.id,
-                    reason: closeReason,
-                    priceClose: averagePrice,
-                    closeTimestamp,
-                    pnlPercentage: pnl.pnlPercentage,
-                });
-                // Предупреждение при убытке от stop_loss
-                if (closeReason === "stop_loss") {
-                    this.params.logger.warn(`ClientStrategy backtest: Signal closed with loss (stop_loss), PNL: ${pnl.pnlPercentage.toFixed(2)}%`);
-                }
-                if (this.params.callbacks?.onClose) {
-                    this.params.callbacks.onClose(this.params.execution.context.symbol, signal, averagePrice, this.params.execution.context.backtest);
+            if (this._scheduledSignal) {
+                // Check if timeout reached (CC_SCHEDULE_AWAIT_MINUTES from scheduledAt)
+                const maxTimeToWait = GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES * 60 * 1000;
+                const lastCandleTimestamp = candles[candles.length - 1].timestamp;
+                const elapsedTime = lastCandleTimestamp - scheduled.scheduledAt;
+                if (elapsedTime < maxTimeToWait) {
+                    // Timeout NOT reached yet - signal is still active (waiting for price)
+                    // Return active result to continue monitoring in next backtest() call
+                    const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
+                    const lastCandles = candles.slice(-candlesCount);
+                    const lastPrice = GET_AVG_PRICE_FN(lastCandles);
+                    this.params.logger.debug("ClientStrategy backtest scheduled signal still waiting (not expired)", {
+                        symbol: this.params.execution.context.symbol,
+                        signalId: scheduled.id,
+                        elapsedMinutes: Math.floor(elapsedTime / 60000),
+                        maxMinutes: GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES,
+                    });
+                    // Don't cancel - just return last active state
+                    // In real backtest flow this won't happen as we process all candles at once,
+                    // but this is correct behavior if someone calls backtest() with partial data
+                    const result = {
+                        action: "active",
+                        signal: scheduled,
+                        currentPrice: lastPrice,
+                        strategyName: this.params.method.context.strategyName,
+                        exchangeName: this.params.method.context.exchangeName,
+                        symbol: this.params.execution.context.symbol,
+                    };
+                    return result; // Cast to IStrategyBacktestResult (which includes Active)
                 }
-                // Remove signal from risk management
-                await this.params.risk.removeSignal(this.params.execution.context.symbol, {
-                    strategyName: this.params.method.context.strategyName,
-                    riskName: this.params.riskName,
-                });
-                await this.setPendingSignal(null);
-                const result = {
-                    action: "closed",
-                    signal: signal,
-                    currentPrice: averagePrice,
-                    closeReason: closeReason,
-                    closeTimestamp: closeTimestamp,
-                    pnl: pnl,
-                    strategyName: this.params.method.context.strategyName,
-                    exchangeName: this.params.method.context.exchangeName,
+                // Timeout reached - cancel the scheduled signal
+                const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
+                const lastCandles = candles.slice(-candlesCount);
+                const lastPrice = GET_AVG_PRICE_FN(lastCandles);
+                this.params.logger.info("ClientStrategy backtest scheduled signal cancelled by timeout", {
                     symbol: this.params.execution.context.symbol,
-                };
-                if (this.params.callbacks?.onTick) {
-                    this.params.callbacks.onTick(this.params.execution.context.symbol, result, this.params.execution.context.backtest);
-                }
-                return result;
+                    signalId: scheduled.id,
+                    closeTimestamp: lastCandleTimestamp,
+                    elapsedMinutes: Math.floor(elapsedTime / 60000),
+                    maxMinutes: GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES,
+                    reason: "timeout - price never reached priceOpen",
+                });
+                return await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(this, scheduled, lastPrice, lastCandleTimestamp);
             }
         }
-        // Если TP/SL не достигнут за период, вычисляем VWAP из последних 5 свечей
-        const lastFiveCandles = candles.slice(-5);
-        const lastPrice = GET_AVG_PRICE_FN(lastFiveCandles);
-        const closeTimestamp = lastFiveCandles[lastFiveCandles.length - 1].timestamp;
-        const pnl = toProfitLossDto(signal, lastPrice);
-        this.params.logger.debug("ClientStrategy backtest time_expired", {
-            symbol: this.params.execution.context.symbol,
-            signalId: signal.id,
-            priceClose: lastPrice,
-            closeTimestamp,
-            pnlPercentage: pnl.pnlPercentage,
-        });
-        // Предупреждение при убытке от time_expired
-        if (pnl.pnlPercentage < 0) {
-            this.params.logger.warn(`ClientStrategy backtest: Signal closed with loss (time_expired), PNL: ${pnl.pnlPercentage.toFixed(2)}%`);
+        // Process pending signal
+        const signal = this._pendingSignal;
+        if (!signal) {
+            throw new Error("ClientStrategy backtest: no pending signal after scheduled activation");
         }
-        if (this.params.callbacks?.onClose) {
-            this.params.callbacks.onClose(this.params.execution.context.symbol, signal, lastPrice, this.params.execution.context.backtest);
+        const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
+        if (candles.length < candlesCount) {
+            this.params.logger.warn(`ClientStrategy backtest: Expected at least ${candlesCount} candles for VWAP, got ${candles.length}`);
         }
-        // Remove signal from risk management
-        await this.params.risk.removeSignal(this.params.execution.context.symbol, {
-            strategyName: this.params.method.context.strategyName,
-            riskName: this.params.riskName,
-        });
-        await this.setPendingSignal(null);
-        const result = {
-            action: "closed",
-            signal: signal,
-            currentPrice: lastPrice,
-            closeReason: "time_expired",
-            closeTimestamp: closeTimestamp,
-            pnl: pnl,
-            strategyName: this.params.method.context.strategyName,
-            exchangeName: this.params.method.context.exchangeName,
-            symbol: this.params.execution.context.symbol,
-        };
-        if (this.params.callbacks?.onTick) {
-            this.params.callbacks.onTick(this.params.execution.context.symbol, result, this.params.execution.context.backtest);
+        const closedResult = await PROCESS_PENDING_SIGNAL_CANDLES_FN(this, signal, candles);
+        if (closedResult) {
+            return closedResult;
         }
-        return result;
+        const lastCandles = candles.slice(-GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT);
+        const lastPrice = GET_AVG_PRICE_FN(lastCandles);
+        const closeTimestamp = lastCandles[lastCandles.length - 1].timestamp;
+        return await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(this, signal, lastPrice, "time_expired", closeTimestamp);
     }
     /**
      * Stops the strategy from generating new signals.
      *
      * Sets internal flag to prevent getSignal from being called.
+     * Clears any scheduled signals (not yet activated).
      * Does NOT close active pending signals - they continue monitoring until TP/SL/time_expired.
      *
      * Use case: Graceful shutdown in live trading without forcing position closure.
@@ -1814,12 +2517,16 @@ class ClientStrategy {
      * // Existing signal will continue until natural close
      * ```
      */
-    stop() {
+    async stop() {
         this.params.logger.debug("ClientStrategy stop", {
             hasPendingSignal: this._pendingSignal !== null,
+            hasScheduledSignal: this._scheduledSignal !== null,
         });
         this._isStopped = true;
-        return Promise.resolve();
+        // Clear scheduled signal if exists
+        if (this._scheduledSignal) {
+            this._scheduledSignal = null;
+        }
     }
 }
 
@@ -2092,9 +2799,10 @@ class FrameConnectionService {
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @returns Promise resolving to { startDate: Date, endDate: Date }
          */
-        this.getTimeframe = async (symbol) => {
+        this.getTimeframe = async (symbol, frameName) => {
             this.loggerService.log("frameConnectionService getTimeframe", {
                 symbol,
+                frameName,
             });
             return await this.getFrame(this.methodContextService.context.frameName).getTimeframe(symbol);
         };
@@ -2575,9 +3283,21 @@ class RiskConnectionService {
             });
             await this.getRisk(context.riskName).removeSignal(symbol, context);
         };
+        /**
+         * Clears the cached ClientRisk instance for the given risk name.
+         *
+         * @param riskName - Name of the risk schema to clear from cache
+         */
+        this.clear = async (riskName) => {
+            this.loggerService.log("riskConnectionService clear", {
+                riskName,
+            });
+            this.getRisk.clear(riskName);
+        };
     }
 }
 
+const METHOD_NAME_VALIDATE$1 = "exchangeGlobalService validate";
 /**
  * Global service for exchange operations with execution context injection.
  *
@@ -2590,6 +3310,21 @@ class ExchangeGlobalService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
+        this.methodContextService = inject(TYPES.methodContextService);
+        this.exchangeValidationService = inject(TYPES.exchangeValidationService);
+        /**
+         * Validates exchange configuration.
+         * Memoized to avoid redundant validations for the same exchange.
+         * Logs validation activity.
+         * @param exchangeName - Name of the exchange to validate
+         * @returns Promise that resolves when validation is complete
+         */
+        this.validate = memoize(([exchangeName]) => `${exchangeName}`, async (exchangeName) => {
+            this.loggerService.log(METHOD_NAME_VALIDATE$1, {
+                exchangeName,
+            });
+            this.exchangeValidationService.validate(exchangeName, METHOD_NAME_VALIDATE$1);
+        });
         /**
          * Fetches historical candles with execution context.
          *
@@ -2608,6 +3343,7 @@ class ExchangeGlobalService {
                 when,
                 backtest,
             });
+            await this.validate(this.methodContextService.context.exchangeName);
             return await ExecutionContextService.runInContext(async () => {
                 return await this.exchangeConnectionService.getCandles(symbol, interval, limit);
             }, {
@@ -2634,6 +3370,7 @@ class ExchangeGlobalService {
                 when,
                 backtest,
             });
+            await this.validate(this.methodContextService.context.exchangeName);
             return await ExecutionContextService.runInContext(async () => {
                 return await this.exchangeConnectionService.getNextCandles(symbol, interval, limit);
             }, {
@@ -2656,6 +3393,7 @@ class ExchangeGlobalService {
                 when,
                 backtest,
             });
+            await this.validate(this.methodContextService.context.exchangeName);
             return await ExecutionContextService.runInContext(async () => {
                 return await this.exchangeConnectionService.getAveragePrice(symbol);
             }, {
@@ -2680,6 +3418,7 @@ class ExchangeGlobalService {
                 when,
                 backtest,
             });
+            await this.validate(this.methodContextService.context.exchangeName);
             return await ExecutionContextService.runInContext(async () => {
                 return await this.exchangeConnectionService.formatPrice(symbol, price);
             }, {
@@ -2704,6 +3443,7 @@ class ExchangeGlobalService {
                 when,
                 backtest,
             });
+            await this.validate(this.methodContextService.context.exchangeName);
             return await ExecutionContextService.runInContext(async () => {
                 return await this.exchangeConnectionService.formatQuantity(symbol, quantity);
             }, {
@@ -2715,6 +3455,7 @@ class ExchangeGlobalService {
     }
 }
 
+const METHOD_NAME_VALIDATE = "strategyGlobalService validate";
 /**
  * Global service for strategy operations with execution context injection.
  *
@@ -2727,6 +3468,28 @@ class StrategyGlobalService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.strategyConnectionService = inject(TYPES.strategyConnectionService);
+        this.strategySchemaService = inject(TYPES.strategySchemaService);
+        this.riskValidationService = inject(TYPES.riskValidationService);
+        this.strategyValidationService = inject(TYPES.strategyValidationService);
+        this.methodContextService = inject(TYPES.methodContextService);
+        /**
+         * Validates strategy and associated risk configuration.
+         *
+         * Memoized to avoid redundant validations for the same strategy.
+         * Logs validation activity.
+         * @param strategyName - Name of the strategy to validate
+         * @returns Promise that resolves when validation is complete
+         */
+        this.validate = memoize(([strategyName]) => `${strategyName}`, async (strategyName) => {
+            this.loggerService.log(METHOD_NAME_VALIDATE, {
+                strategyName,
+            });
+            const strategySchema = this.strategySchemaService.get(strategyName);
+            this.strategyValidationService.validate(strategyName, METHOD_NAME_VALIDATE);
+            const riskName = strategySchema.riskName;
+            riskName &&
+                this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE);
+        });
         /**
          * Checks signal status at a specific timestamp.
          *
@@ -2744,6 +3507,7 @@ class StrategyGlobalService {
                 when,
                 backtest,
             });
+            await this.validate(this.methodContextService.context.strategyName);
             return await ExecutionContextService.runInContext(async () => {
                 return await this.strategyConnectionService.tick();
             }, {
@@ -2771,6 +3535,7 @@ class StrategyGlobalService {
                 when,
                 backtest,
             });
+            await this.validate(this.methodContextService.context.strategyName);
             return await ExecutionContextService.runInContext(async () => {
                 return await this.strategyConnectionService.backtest(candles);
             }, {
@@ -2792,6 +3557,7 @@ class StrategyGlobalService {
             this.loggerService.log("strategyGlobalService stop", {
                 strategyName,
             });
+            await this.validate(strategyName);
             return await this.strategyConnectionService.stop(strategyName);
         };
         /**
@@ -2806,11 +3572,15 @@ class StrategyGlobalService {
             this.loggerService.log("strategyGlobalService clear", {
                 strategyName,
             });
+            if (strategyName) {
+                await this.validate(strategyName);
+            }
             return await this.strategyConnectionService.clear(strategyName);
         };
     }
 }
 
+const METHOD_NAME_GET_TIMEFRAME = "frameGlobalService getTimeframe";
 /**
  * Global service for frame operations.
  *
@@ -2821,21 +3591,25 @@ class FrameGlobalService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.frameConnectionService = inject(TYPES.frameConnectionService);
+        this.frameValidationService = inject(TYPES.frameValidationService);
         /**
          * Generates timeframe array for backtest iteration.
          *
-         * @param symbol - Trading pair symbol
+         * @param frameName - Target frame name (e.g., "1m", "1h")
          * @returns Promise resolving to array of Date objects
          */
-        this.getTimeframe = async (symbol) => {
-            this.loggerService.log("frameGlobalService getTimeframe", {
+        this.getTimeframe = async (symbol, frameName) => {
+            this.loggerService.log(METHOD_NAME_GET_TIMEFRAME, {
+                frameName,
                 symbol,
             });
-            return await this.frameConnectionService.getTimeframe(symbol);
+            this.frameValidationService.validate(frameName, METHOD_NAME_GET_TIMEFRAME);
+            return await this.frameConnectionService.getTimeframe(symbol, frameName);
         };
     }
 }
 
+const METHOD_NAME_CALCULATE = "sizingGlobalService calculate";
 /**
  * Global service for sizing operations.
  *
@@ -2846,6 +3620,7 @@ class SizingGlobalService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.sizingConnectionService = inject(TYPES.sizingConnectionService);
+        this.sizingValidationService = inject(TYPES.sizingValidationService);
         /**
          * Calculates position size based on risk parameters.
          *
@@ -2854,11 +3629,12 @@ class SizingGlobalService {
          * @returns Promise resolving to calculated position size
          */
         this.calculate = async (params, context) => {
-            this.loggerService.log("sizingGlobalService calculate", {
+            this.loggerService.log(METHOD_NAME_CALCULATE, {
                 symbol: params.symbol,
                 method: params.method,
                 context,
             });
+            this.sizingValidationService.validate(context.sizingName, METHOD_NAME_CALCULATE);
             return await this.sizingConnectionService.calculate(params, context);
         };
     }
@@ -2874,6 +3650,20 @@ class RiskGlobalService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.riskConnectionService = inject(TYPES.riskConnectionService);
+        this.riskValidationService = inject(TYPES.riskValidationService);
+        /**
+         * Validates risk configuration.
+         * Memoized to avoid redundant validations for the same risk instance.
+         * Logs validation activity.
+         * @param riskName - Name of the risk instance to validate
+         * @returns Promise that resolves when validation is complete
+         */
+        this.validate = memoize(([riskName]) => `${riskName}`, async (riskName) => {
+            this.loggerService.log("riskGlobalService validate", {
+                riskName,
+            });
+            this.riskValidationService.validate(riskName, "riskGlobalService validate");
+        });
         /**
          * Checks if a signal should be allowed based on risk limits.
          *
@@ -2886,6 +3676,7 @@ class RiskGlobalService {
                 symbol: params.symbol,
                 context,
             });
+            await this.validate(context.riskName);
             return await this.riskConnectionService.checkSignal(params, context);
         };
         /**
@@ -2899,6 +3690,7 @@ class RiskGlobalService {
                 symbol,
                 context,
             });
+            await this.validate(context.riskName);
             await this.riskConnectionService.addSignal(symbol, context);
         };
         /**
@@ -2912,8 +3704,24 @@ class RiskGlobalService {
                 symbol,
                 context,
             });
+            await this.validate(context.riskName);
             await this.riskConnectionService.removeSignal(symbol, context);
         };
+        /**
+         * Clears risk data.
+         * If riskName is provided, clears data for that specific risk instance.
+         * If no riskName is provided, clears all risk data.
+         * @param riskName - Optional name of the risk instance to clear
+         */
+        this.clear = async (riskName) => {
+            this.loggerService.log("riskGlobalService clear", {
+                riskName,
+            });
+            if (riskName) {
+                await this.validate(riskName);
+            }
+            return await this.riskConnectionService.clear(riskName);
+        };
     }
 }
 
@@ -3424,7 +4232,7 @@ class BacktestLogicPrivateService {
             symbol,
         });
         const backtestStartTime = performance.now();
-        const timeframes = await this.frameGlobalService.getTimeframe(symbol);
+        const timeframes = await this.frameGlobalService.getTimeframe(symbol, this.methodContextService.context.frameName);
         const totalFrames = timeframes.length;
         let i = 0;
         let previousEventTimestamp = null;
@@ -3443,7 +4251,66 @@ class BacktestLogicPrivateService {
                 });
             }
             const result = await this.strategyGlobalService.tick(symbol, when, true);
-            // Если сигнал открыт, вызываем backtest
+            // Если scheduled signal создан - обрабатываем через backtest()
+            if (result.action === "scheduled") {
+                const signalStartTime = performance.now();
+                const signal = result.signal;
+                this.loggerService.info("backtestLogicPrivateService scheduled signal detected", {
+                    symbol,
+                    signalId: signal.id,
+                    priceOpen: signal.priceOpen,
+                    minuteEstimatedTime: signal.minuteEstimatedTime,
+                });
+                // Запрашиваем минутные свечи для мониторинга активации/отмены
+                // КРИТИЧНО: запрашиваем CC_SCHEDULE_AWAIT_MINUTES для ожидания активации
+                // + minuteEstimatedTime для работы сигнала ПОСЛЕ активации
+                // +1 потому что when включается как первая свеча (timestamp начинается с when, а не after when)
+                const candlesNeeded = GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES + signal.minuteEstimatedTime + 1;
+                const candles = await this.exchangeGlobalService.getNextCandles(symbol, "1m", candlesNeeded, when, true);
+                if (!candles.length) {
+                    i++;
+                    continue;
+                }
+                this.loggerService.info("backtestLogicPrivateService candles fetched for scheduled", {
+                    symbol,
+                    signalId: signal.id,
+                    candlesCount: candles.length,
+                    candlesNeeded,
+                });
+                // backtest() сам обработает scheduled signal: найдет активацию/отмену
+                // и если активируется - продолжит с TP/SL мониторингом
+                const backtestResult = await this.strategyGlobalService.backtest(symbol, candles, when, true);
+                this.loggerService.info("backtestLogicPrivateService scheduled signal closed", {
+                    symbol,
+                    signalId: backtestResult.signal.id,
+                    closeTimestamp: backtestResult.closeTimestamp,
+                    action: backtestResult.action,
+                    closeReason: backtestResult.action === "closed"
+                        ? backtestResult.closeReason
+                        : undefined,
+                });
+                // Track signal processing duration
+                const signalEndTime = performance.now();
+                const currentTimestamp = Date.now();
+                await performanceEmitter.next({
+                    timestamp: currentTimestamp,
+                    previousTimestamp: previousEventTimestamp,
+                    metricType: "backtest_signal",
+                    duration: signalEndTime - signalStartTime,
+                    strategyName: this.methodContextService.context.strategyName,
+                    exchangeName: this.methodContextService.context.exchangeName,
+                    symbol,
+                    backtest: true,
+                });
+                previousEventTimestamp = currentTimestamp;
+                // Пропускаем timeframes до closeTimestamp
+                while (i < timeframes.length &&
+                    timeframes[i].getTime() < backtestResult.closeTimestamp) {
+                    i++;
+                }
+                yield backtestResult;
+            }
+            // Если обычный сигнал открыт, вызываем backtest
             if (result.action === "opened") {
                 const signalStartTime = performance.now();
                 const signal = result.signal;
@@ -3468,7 +4335,6 @@ class BacktestLogicPrivateService {
                     symbol,
                     signalId: backtestResult.signal.id,
                     closeTimestamp: backtestResult.closeTimestamp,
-                    closeReason: backtestResult.closeReason,
                 });
                 // Track signal processing duration
                 const signalEndTime = performance.now();
@@ -3615,6 +4481,11 @@ class LiveLogicPrivateService {
                 await sleep(TICK_TTL);
                 continue;
             }
+            if (result.action === "scheduled") {
+                await sleep(TICK_TTL);
+                continue;
+            }
+            // Yield opened, closed, cancelled results
             yield result;
             await sleep(TICK_TTL);
         }
@@ -3935,6 +4806,8 @@ class LiveGlobalService {
         this.liveLogicPublicService = inject(TYPES.liveLogicPublicService);
         this.strategyValidationService = inject(TYPES.strategyValidationService);
         this.exchangeValidationService = inject(TYPES.exchangeValidationService);
+        this.strategySchemaService = inject(TYPES.strategySchemaService);
+        this.riskValidationService = inject(TYPES.riskValidationService);
         /**
          * Runs live trading for a symbol with context propagation.
          *
@@ -3949,8 +4822,16 @@ class LiveGlobalService {
                 symbol,
                 context,
             });
-            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_RUN$2);
-            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN$2);
+            {
+                this.strategyValidationService.validate(context.strategyName, METHOD_NAME_RUN$2);
+                this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN$2);
+            }
+            {
+                const strategySchema = this.strategySchemaService.get(context.strategyName);
+                const riskName = strategySchema.riskName;
+                riskName &&
+                    this.riskValidationService.validate(riskName, METHOD_NAME_RUN$2);
+            }
             return this.liveLogicPublicService.run(symbol, context);
         };
     }
@@ -3966,6 +4847,8 @@ const METHOD_NAME_RUN$1 = "backtestGlobalService run";
 class BacktestGlobalService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
+        this.strategySchemaService = inject(TYPES.strategySchemaService);
+        this.riskValidationService = inject(TYPES.riskValidationService);
         this.backtestLogicPublicService = inject(TYPES.backtestLogicPublicService);
         this.strategyValidationService = inject(TYPES.strategyValidationService);
         this.exchangeValidationService = inject(TYPES.exchangeValidationService);
@@ -3982,9 +4865,16 @@ class BacktestGlobalService {
                 symbol,
                 context,
             });
-            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_RUN$1);
-            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN$1);
-            this.frameValidationService.validate(context.frameName, METHOD_NAME_RUN$1);
+            {
+                this.strategyValidationService.validate(context.strategyName, METHOD_NAME_RUN$1);
+                this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN$1);
+                this.frameValidationService.validate(context.frameName, METHOD_NAME_RUN$1);
+            }
+            {
+                const strategySchema = this.strategySchemaService.get(context.strategyName);
+                const riskName = strategySchema.riskName;
+                riskName && this.riskValidationService.validate(riskName, METHOD_NAME_RUN$1);
+            }
             return this.backtestLogicPublicService.run(symbol, context);
         };
     }
@@ -4001,6 +4891,13 @@ class WalkerGlobalService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.walkerLogicPublicService = inject(TYPES.walkerLogicPublicService);
+        this.walkerSchemaService = inject(TYPES.walkerSchemaService);
+        this.strategyValidationService = inject(TYPES.strategyValidationService);
+        this.exchangeValidationService = inject(TYPES.exchangeValidationService);
+        this.frameValidationService = inject(TYPES.frameValidationService);
+        this.walkerValidationService = inject(TYPES.walkerValidationService);
+        this.strategySchemaService = inject(TYPES.strategySchemaService);
+        this.riskValidationService = inject(TYPES.riskValidationService);
         /**
          * Runs walker comparison for a symbol with context propagation.
          *
@@ -4012,6 +4909,21 @@ class WalkerGlobalService {
                 symbol,
                 context,
             });
+            {
+                this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN);
+                this.frameValidationService.validate(context.frameName, METHOD_NAME_RUN);
+                this.walkerValidationService.validate(context.walkerName, METHOD_NAME_RUN);
+            }
+            {
+                const walkerSchema = this.walkerSchemaService.get(context.walkerName);
+                for (const strategyName of walkerSchema.strategies) {
+                    const strategySchema = this.strategySchemaService.get(strategyName);
+                    this.strategyValidationService.validate(strategyName, METHOD_NAME_RUN);
+                    const riskName = strategySchema.riskName;
+                    riskName &&
+                        this.riskValidationService.validate(riskName, METHOD_NAME_RUN);
+                }
+            }
             return this.walkerLogicPublicService.run(symbol, context);
         };
     }
@@ -4035,7 +4947,7 @@ function isUnsafe$3(value) {
     }
     return false;
 }
-const columns$2 = [
+const columns$3 = [
     {
         key: "signalId",
         label: "Signal ID",
@@ -4093,7 +5005,7 @@ const columns$2 = [
         key: "duration",
         label: "Duration (min)",
         format: (data) => {
-            const durationMs = data.closeTimestamp - data.signal.timestamp;
+            const durationMs = data.closeTimestamp - data.signal.pendingAt;
             const durationMin = Math.round(durationMs / 60000);
             return `${durationMin}`;
         },
@@ -4101,7 +5013,7 @@ const columns$2 = [
     {
         key: "openTimestamp",
         label: "Open Time",
-        format: (data) => new Date(data.signal.timestamp).toISOString(),
+        format: (data) => new Date(data.signal.pendingAt).toISOString(),
     },
     {
         key: "closeTimestamp",
@@ -4113,7 +5025,7 @@ const columns$2 = [
  * Storage class for accumulating closed signals per strategy.
  * Maintains a list of all closed signals and provides methods to generate reports.
  */
-let ReportStorage$2 = class ReportStorage {
+let ReportStorage$3 = class ReportStorage {
     constructor() {
         /** Internal list of all closed signals for this strategy */
         this._signalList = [];
@@ -4173,7 +5085,7 @@ let ReportStorage$2 = class ReportStorage {
             : 0;
         const certaintyRatio = avgLoss < 0 ? avgWin / Math.abs(avgLoss) : 0;
         // Calculate Expected Yearly Returns
-        const avgDurationMs = this._signalList.reduce((sum, s) => sum + (s.closeTimestamp - s.signal.timestamp), 0) / totalSignals;
+        const avgDurationMs = this._signalList.reduce((sum, s) => sum + (s.closeTimestamp - s.signal.pendingAt), 0) / totalSignals;
         const avgDurationDays = avgDurationMs / (1000 * 60 * 60 * 24);
         const tradesPerYear = avgDurationDays > 0 ? 365 / avgDurationDays : 0;
         const expectedYearlyReturns = avgPnl * tradesPerYear;
@@ -4203,9 +5115,9 @@ let ReportStorage$2 = class ReportStorage {
         if (stats.totalSignals === 0) {
             return str.newline(`# Backtest Report: ${strategyName}`, "", "No signals closed yet.");
         }
-        const header = columns$2.map((col) => col.label);
-        const separator = columns$2.map(() => "---");
-        const rows = this._signalList.map((closedSignal) => columns$2.map((col) => col.format(closedSignal)));
+        const header = columns$3.map((col) => col.label);
+        const separator = columns$3.map(() => "---");
+        const rows = this._signalList.map((closedSignal) => columns$3.map((col) => col.format(closedSignal)));
         const tableData = [header, separator, ...rows];
         const table = str.newline(tableData.map(row => `| ${row.join(" | ")} |`));
         return str.newline(`# Backtest Report: ${strategyName}`, "", table, "", `**Total signals:** ${stats.totalSignals}`, `**Closed signals:** ${stats.totalSignals}`, `**Win rate:** ${stats.winRate === null ? "N/A" : `${stats.winRate.toFixed(2)}% (${stats.winCount}W / ${stats.lossCount}L) (higher is better)`}`, `**Average PNL:** ${stats.avgPnl === null ? "N/A" : `${stats.avgPnl > 0 ? "+" : ""}${stats.avgPnl.toFixed(2)}% (higher is better)`}`, `**Total PNL:** ${stats.totalPnl === null ? "N/A" : `${stats.totalPnl > 0 ? "+" : ""}${stats.totalPnl.toFixed(2)}% (higher is better)`}`, `**Standard Deviation:** ${stats.stdDev === null ? "N/A" : `${stats.stdDev.toFixed(3)}% (lower is better)`}`, `**Sharpe Ratio:** ${stats.sharpeRatio === null ? "N/A" : `${stats.sharpeRatio.toFixed(3)} (higher is better)`}`, `**Annualized Sharpe Ratio:** ${stats.annualizedSharpeRatio === null ? "N/A" : `${stats.annualizedSharpeRatio.toFixed(3)} (higher is better)`}`, `**Certainty Ratio:** ${stats.certaintyRatio === null ? "N/A" : `${stats.certaintyRatio.toFixed(3)} (higher is better)`}`, `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better)`}`);
@@ -4266,7 +5178,7 @@ class BacktestMarkdownService {
          * Memoized function to get or create ReportStorage for a strategy.
          * Each strategy gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$2());
+        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$3());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -4425,7 +5337,7 @@ function isUnsafe$2(value) {
     }
     return false;
 }
-const columns$1 = [
+const columns$2 = [
     {
         key: "timestamp",
         label: "Timestamp",
@@ -4499,12 +5411,12 @@ const columns$1 = [
     },
 ];
 /** Maximum number of events to store in live trading reports */
-const MAX_EVENTS$1 = 250;
+const MAX_EVENTS$2 = 250;
 /**
  * Storage class for accumulating all tick events per strategy.
  * Maintains a chronological list of all events (idle, opened, active, closed).
  */
-let ReportStorage$1 = class ReportStorage {
+let ReportStorage$2 = class ReportStorage {
     constructor() {
         /** Internal list of all tick events for this strategy */
         this._eventList = [];
@@ -4532,7 +5444,7 @@ let ReportStorage$1 = class ReportStorage {
         }
         {
             this._eventList.push(newEvent);
-            if (this._eventList.length > MAX_EVENTS$1) {
+            if (this._eventList.length > MAX_EVENTS$2) {
                 this._eventList.shift();
             }
         }
@@ -4544,7 +5456,7 @@ let ReportStorage$1 = class ReportStorage {
      */
     addOpenedEvent(data) {
         this._eventList.push({
-            timestamp: data.signal.timestamp,
+            timestamp: data.signal.pendingAt,
             action: "opened",
             symbol: data.signal.symbol,
             signalId: data.signal.id,
@@ -4556,7 +5468,7 @@ let ReportStorage$1 = class ReportStorage {
             stopLoss: data.signal.priceStopLoss,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$1) {
+        if (this._eventList.length > MAX_EVENTS$2) {
             this._eventList.shift();
         }
     }
@@ -4588,35 +5500,472 @@ let ReportStorage$1 = class ReportStorage {
         else {
             this._eventList.push(newEvent);
             // Trim queue if exceeded MAX_EVENTS
-            if (this._eventList.length > MAX_EVENTS$1) {
+            if (this._eventList.length > MAX_EVENTS$2) {
+                this._eventList.shift();
+            }
+        }
+    }
+    /**
+     * Updates or adds a closed event to the storage.
+     * Replaces the previous event with the same signalId.
+     *
+     * @param data - Closed tick result
+     */
+    addClosedEvent(data) {
+        const durationMs = data.closeTimestamp - data.signal.pendingAt;
+        const durationMin = Math.round(durationMs / 60000);
+        // Find existing event with the same signalId
+        const existingIndex = this._eventList.findIndex((event) => event.signalId === data.signal.id);
+        const newEvent = {
+            timestamp: data.closeTimestamp,
+            action: "closed",
+            symbol: data.signal.symbol,
+            signalId: data.signal.id,
+            position: data.signal.position,
+            note: data.signal.note,
+            currentPrice: data.currentPrice,
+            openPrice: data.signal.priceOpen,
+            takeProfit: data.signal.priceTakeProfit,
+            stopLoss: data.signal.priceStopLoss,
+            pnl: data.pnl.pnlPercentage,
+            closeReason: data.closeReason,
+            duration: durationMin,
+        };
+        // Replace existing event or add new one
+        if (existingIndex !== -1) {
+            this._eventList[existingIndex] = newEvent;
+        }
+        else {
+            this._eventList.push(newEvent);
+            // Trim queue if exceeded MAX_EVENTS
+            if (this._eventList.length > MAX_EVENTS$2) {
                 this._eventList.shift();
             }
         }
     }
     /**
-     * Updates or adds a closed event to the storage.
+     * Calculates statistical data from live trading events (Controller).
+     * Returns null for any unsafe numeric values (NaN, Infinity, etc).
+     *
+     * @returns Statistical data (empty object if no events)
+     */
+    async getData() {
+        if (this._eventList.length === 0) {
+            return {
+                eventList: [],
+                totalEvents: 0,
+                totalClosed: 0,
+                winCount: 0,
+                lossCount: 0,
+                winRate: null,
+                avgPnl: null,
+                totalPnl: null,
+                stdDev: null,
+                sharpeRatio: null,
+                annualizedSharpeRatio: null,
+                certaintyRatio: null,
+                expectedYearlyReturns: null,
+            };
+        }
+        const closedEvents = this._eventList.filter((e) => e.action === "closed");
+        const totalClosed = closedEvents.length;
+        const winCount = closedEvents.filter((e) => e.pnl && e.pnl > 0).length;
+        const lossCount = closedEvents.filter((e) => e.pnl && e.pnl < 0).length;
+        // Calculate basic statistics
+        const avgPnl = totalClosed > 0
+            ? closedEvents.reduce((sum, e) => sum + (e.pnl || 0), 0) / totalClosed
+            : 0;
+        const totalPnl = closedEvents.reduce((sum, e) => sum + (e.pnl || 0), 0);
+        const winRate = (winCount / totalClosed) * 100;
+        // Calculate Sharpe Ratio (risk-free rate = 0)
+        let sharpeRatio = 0;
+        let stdDev = 0;
+        if (totalClosed > 0) {
+            const returns = closedEvents.map((e) => e.pnl || 0);
+            const variance = returns.reduce((sum, r) => sum + Math.pow(r - avgPnl, 2), 0) / totalClosed;
+            stdDev = Math.sqrt(variance);
+            sharpeRatio = stdDev > 0 ? avgPnl / stdDev : 0;
+        }
+        const annualizedSharpeRatio = sharpeRatio * Math.sqrt(365);
+        // Calculate Certainty Ratio
+        let certaintyRatio = 0;
+        if (totalClosed > 0) {
+            const wins = closedEvents.filter((e) => e.pnl && e.pnl > 0);
+            const losses = closedEvents.filter((e) => e.pnl && e.pnl < 0);
+            const avgWin = wins.length > 0
+                ? wins.reduce((sum, e) => sum + (e.pnl || 0), 0) / wins.length
+                : 0;
+            const avgLoss = losses.length > 0
+                ? losses.reduce((sum, e) => sum + (e.pnl || 0), 0) / losses.length
+                : 0;
+            certaintyRatio = avgLoss < 0 ? avgWin / Math.abs(avgLoss) : 0;
+        }
+        // Calculate Expected Yearly Returns
+        let expectedYearlyReturns = 0;
+        if (totalClosed > 0) {
+            const avgDurationMin = closedEvents.reduce((sum, e) => sum + (e.duration || 0), 0) / totalClosed;
+            const avgDurationDays = avgDurationMin / (60 * 24);
+            const tradesPerYear = avgDurationDays > 0 ? 365 / avgDurationDays : 0;
+            expectedYearlyReturns = avgPnl * tradesPerYear;
+        }
+        return {
+            eventList: this._eventList,
+            totalEvents: this._eventList.length,
+            totalClosed,
+            winCount,
+            lossCount,
+            winRate: isUnsafe$2(winRate) ? null : winRate,
+            avgPnl: isUnsafe$2(avgPnl) ? null : avgPnl,
+            totalPnl: isUnsafe$2(totalPnl) ? null : totalPnl,
+            stdDev: isUnsafe$2(stdDev) ? null : stdDev,
+            sharpeRatio: isUnsafe$2(sharpeRatio) ? null : sharpeRatio,
+            annualizedSharpeRatio: isUnsafe$2(annualizedSharpeRatio) ? null : annualizedSharpeRatio,
+            certaintyRatio: isUnsafe$2(certaintyRatio) ? null : certaintyRatio,
+            expectedYearlyReturns: isUnsafe$2(expectedYearlyReturns) ? null : expectedYearlyReturns,
+        };
+    }
+    /**
+     * Generates markdown report with all tick events for a strategy (View).
+     *
+     * @param strategyName - Strategy name
+     * @returns Markdown formatted report with all events
+     */
+    async getReport(strategyName) {
+        const stats = await this.getData();
+        if (stats.totalEvents === 0) {
+            return str.newline(`# Live Trading Report: ${strategyName}`, "", "No events recorded yet.");
+        }
+        const header = columns$2.map((col) => col.label);
+        const separator = columns$2.map(() => "---");
+        const rows = this._eventList.map((event) => columns$2.map((col) => col.format(event)));
+        const tableData = [header, separator, ...rows];
+        const table = str.newline(tableData.map(row => `| ${row.join(" | ")} |`));
+        return str.newline(`# Live Trading Report: ${strategyName}`, "", table, "", `**Total events:** ${stats.totalEvents}`, `**Closed signals:** ${stats.totalClosed}`, `**Win rate:** ${stats.winRate === null ? "N/A" : `${stats.winRate.toFixed(2)}% (${stats.winCount}W / ${stats.lossCount}L) (higher is better)`}`, `**Average PNL:** ${stats.avgPnl === null ? "N/A" : `${stats.avgPnl > 0 ? "+" : ""}${stats.avgPnl.toFixed(2)}% (higher is better)`}`, `**Total PNL:** ${stats.totalPnl === null ? "N/A" : `${stats.totalPnl > 0 ? "+" : ""}${stats.totalPnl.toFixed(2)}% (higher is better)`}`, `**Standard Deviation:** ${stats.stdDev === null ? "N/A" : `${stats.stdDev.toFixed(3)}% (lower is better)`}`, `**Sharpe Ratio:** ${stats.sharpeRatio === null ? "N/A" : `${stats.sharpeRatio.toFixed(3)} (higher is better)`}`, `**Annualized Sharpe Ratio:** ${stats.annualizedSharpeRatio === null ? "N/A" : `${stats.annualizedSharpeRatio.toFixed(3)} (higher is better)`}`, `**Certainty Ratio:** ${stats.certaintyRatio === null ? "N/A" : `${stats.certaintyRatio.toFixed(3)} (higher is better)`}`, `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better)`}`);
+    }
+    /**
+     * Saves strategy report to disk.
+     *
+     * @param strategyName - Strategy name
+     * @param path - Directory path to save report (default: "./logs/live")
+     */
+    async dump(strategyName, path = "./logs/live") {
+        const markdown = await this.getReport(strategyName);
+        try {
+            const dir = join(process.cwd(), path);
+            await mkdir(dir, { recursive: true });
+            const filename = `${strategyName}.md`;
+            const filepath = join(dir, filename);
+            await writeFile(filepath, markdown, "utf-8");
+            console.log(`Live trading report saved: ${filepath}`);
+        }
+        catch (error) {
+            console.error(`Failed to save markdown report:`, error);
+        }
+    }
+};
+/**
+ * Service for generating and saving live trading markdown reports.
+ *
+ * Features:
+ * - Listens to all signal events via onTick callback
+ * - Accumulates all events (idle, opened, active, closed) per strategy
+ * - Generates markdown tables with detailed event information
+ * - Provides trading statistics (win rate, average PNL)
+ * - Saves reports to disk in logs/live/{strategyName}.md
+ *
+ * @example
+ * ```typescript
+ * const service = new LiveMarkdownService();
+ *
+ * // Add to strategy callbacks
+ * addStrategy({
+ *   strategyName: "my-strategy",
+ *   callbacks: {
+ *     onTick: (symbol, result, backtest) => {
+ *       if (!backtest) {
+ *         service.tick(result);
+ *       }
+ *     }
+ *   }
+ * });
+ *
+ * // Later: generate and save report
+ * await service.dump("my-strategy");
+ * ```
+ */
+class LiveMarkdownService {
+    constructor() {
+        /** Logger service for debug output */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Memoized function to get or create ReportStorage for a strategy.
+         * Each strategy gets its own isolated storage instance.
+         */
+        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$2());
+        /**
+         * Processes tick events and accumulates all event types.
+         * Should be called from IStrategyCallbacks.onTick.
+         *
+         * Processes all event types: idle, opened, active, closed.
+         *
+         * @param data - Tick result from strategy execution
+         *
+         * @example
+         * ```typescript
+         * const service = new LiveMarkdownService();
+         *
+         * callbacks: {
+         *   onTick: (symbol, result, backtest) => {
+         *     if (!backtest) {
+         *       service.tick(result);
+         *     }
+         *   }
+         * }
+         * ```
+         */
+        this.tick = async (data) => {
+            this.loggerService.log("liveMarkdownService tick", {
+                data,
+            });
+            const storage = this.getStorage(data.strategyName);
+            if (data.action === "idle") {
+                storage.addIdleEvent(data.currentPrice);
+            }
+            else if (data.action === "opened") {
+                storage.addOpenedEvent(data);
+            }
+            else if (data.action === "active") {
+                storage.addActiveEvent(data);
+            }
+            else if (data.action === "closed") {
+                storage.addClosedEvent(data);
+            }
+        };
+        /**
+         * Gets statistical data from all live trading events for a strategy.
+         * Delegates to ReportStorage.getData().
+         *
+         * @param strategyName - Strategy name to get data for
+         * @returns Statistical data object with all metrics
+         *
+         * @example
+         * ```typescript
+         * const service = new LiveMarkdownService();
+         * const stats = await service.getData("my-strategy");
+         * console.log(stats.sharpeRatio, stats.winRate);
+         * ```
+         */
+        this.getData = async (strategyName) => {
+            this.loggerService.log("liveMarkdownService getData", {
+                strategyName,
+            });
+            const storage = this.getStorage(strategyName);
+            return storage.getData();
+        };
+        /**
+         * Generates markdown report with all events for a strategy.
+         * Delegates to ReportStorage.getReport().
+         *
+         * @param strategyName - Strategy name to generate report for
+         * @returns Markdown formatted report string with table of all events
+         *
+         * @example
+         * ```typescript
+         * const service = new LiveMarkdownService();
+         * const markdown = await service.getReport("my-strategy");
+         * console.log(markdown);
+         * ```
+         */
+        this.getReport = async (strategyName) => {
+            this.loggerService.log("liveMarkdownService getReport", {
+                strategyName,
+            });
+            const storage = this.getStorage(strategyName);
+            return storage.getReport(strategyName);
+        };
+        /**
+         * Saves strategy report to disk.
+         * Creates directory if it doesn't exist.
+         * Delegates to ReportStorage.dump().
+         *
+         * @param strategyName - Strategy name to save report for
+         * @param path - Directory path to save report (default: "./logs/live")
+         *
+         * @example
+         * ```typescript
+         * const service = new LiveMarkdownService();
+         *
+         * // Save to default path: ./logs/live/my-strategy.md
+         * await service.dump("my-strategy");
+         *
+         * // Save to custom path: ./custom/path/my-strategy.md
+         * await service.dump("my-strategy", "./custom/path");
+         * ```
+         */
+        this.dump = async (strategyName, path = "./logs/live") => {
+            this.loggerService.log("liveMarkdownService dump", {
+                strategyName,
+                path,
+            });
+            const storage = this.getStorage(strategyName);
+            await storage.dump(strategyName, path);
+        };
+        /**
+         * Clears accumulated event data from storage.
+         * If strategyName is provided, clears only that strategy's data.
+         * If strategyName is omitted, clears all strategies' data.
+         *
+         * @param strategyName - Optional strategy name to clear specific strategy data
+         *
+         * @example
+         * ```typescript
+         * const service = new LiveMarkdownService();
+         *
+         * // Clear specific strategy data
+         * await service.clear("my-strategy");
+         *
+         * // Clear all strategies' data
+         * await service.clear();
+         * ```
+         */
+        this.clear = async (strategyName) => {
+            this.loggerService.log("liveMarkdownService clear", {
+                strategyName,
+            });
+            this.getStorage.clear(strategyName);
+        };
+        /**
+         * Initializes the service by subscribing to live signal events.
+         * Uses singleshot to ensure initialization happens only once.
+         * Automatically called on first use.
+         *
+         * @example
+         * ```typescript
+         * const service = new LiveMarkdownService();
+         * await service.init(); // Subscribe to live events
+         * ```
+         */
+        this.init = singleshot(async () => {
+            this.loggerService.log("liveMarkdownService init");
+            signalLiveEmitter.subscribe(this.tick);
+        });
+    }
+}
+
+const columns$1 = [
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+    },
+    {
+        key: "action",
+        label: "Action",
+        format: (data) => data.action.toUpperCase(),
+    },
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.signalId,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.position.toUpperCase(),
+    },
+    {
+        key: "note",
+        label: "Note",
+        format: (data) => data.note ?? "N/A",
+    },
+    {
+        key: "currentPrice",
+        label: "Current Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+    },
+    {
+        key: "priceOpen",
+        label: "Entry Price",
+        format: (data) => `${data.priceOpen.toFixed(8)} USD`,
+    },
+    {
+        key: "takeProfit",
+        label: "Take Profit",
+        format: (data) => `${data.takeProfit.toFixed(8)} USD`,
+    },
+    {
+        key: "stopLoss",
+        label: "Stop Loss",
+        format: (data) => `${data.stopLoss.toFixed(8)} USD`,
+    },
+    {
+        key: "duration",
+        label: "Wait Time (min)",
+        format: (data) => data.duration !== undefined ? `${data.duration}` : "N/A",
+    },
+];
+/** Maximum number of events to store in schedule reports */
+const MAX_EVENTS$1 = 250;
+/**
+ * Storage class for accumulating scheduled signal events per strategy.
+ * Maintains a chronological list of scheduled and cancelled events.
+ */
+let ReportStorage$1 = class ReportStorage {
+    constructor() {
+        /** Internal list of all scheduled events for this strategy */
+        this._eventList = [];
+    }
+    /**
+     * Adds a scheduled event to the storage.
+     *
+     * @param data - Scheduled tick result
+     */
+    addScheduledEvent(data) {
+        this._eventList.push({
+            timestamp: data.signal.scheduledAt,
+            action: "scheduled",
+            symbol: data.signal.symbol,
+            signalId: data.signal.id,
+            position: data.signal.position,
+            note: data.signal.note,
+            currentPrice: data.currentPrice,
+            priceOpen: data.signal.priceOpen,
+            takeProfit: data.signal.priceTakeProfit,
+            stopLoss: data.signal.priceStopLoss,
+        });
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._eventList.length > MAX_EVENTS$1) {
+            this._eventList.shift();
+        }
+    }
+    /**
+     * Updates or adds a cancelled event to the storage.
      * Replaces the previous event with the same signalId.
      *
-     * @param data - Closed tick result
+     * @param data - Cancelled tick result
      */
-    addClosedEvent(data) {
-        const durationMs = data.closeTimestamp - data.signal.timestamp;
+    addCancelledEvent(data) {
+        const durationMs = data.closeTimestamp - data.signal.scheduledAt;
         const durationMin = Math.round(durationMs / 60000);
         // Find existing event with the same signalId
         const existingIndex = this._eventList.findIndex((event) => event.signalId === data.signal.id);
         const newEvent = {
             timestamp: data.closeTimestamp,
-            action: "closed",
+            action: "cancelled",
             symbol: data.signal.symbol,
             signalId: data.signal.id,
             position: data.signal.position,
             note: data.signal.note,
             currentPrice: data.currentPrice,
-            openPrice: data.signal.priceOpen,
+            priceOpen: data.signal.priceOpen,
             takeProfit: data.signal.priceTakeProfit,
             stopLoss: data.signal.priceStopLoss,
-            pnl: data.pnl.pnlPercentage,
-            closeReason: data.closeReason,
+            closeTimestamp: data.closeTimestamp,
             duration: durationMin,
         };
         // Replace existing event or add new one
@@ -4632,8 +5981,7 @@ let ReportStorage$1 = class ReportStorage {
         }
     }
     /**
-     * Calculates statistical data from live trading events (Controller).
-     * Returns null for any unsafe numeric values (NaN, Infinity, etc).
+     * Calculates statistical data from scheduled signal events (Controller).
      *
      * @returns Statistical data (empty object if no events)
      */
@@ -4642,78 +5990,34 @@ let ReportStorage$1 = class ReportStorage {
             return {
                 eventList: [],
                 totalEvents: 0,
-                totalClosed: 0,
-                winCount: 0,
-                lossCount: 0,
-                winRate: null,
-                avgPnl: null,
-                totalPnl: null,
-                stdDev: null,
-                sharpeRatio: null,
-                annualizedSharpeRatio: null,
-                certaintyRatio: null,
-                expectedYearlyReturns: null,
+                totalScheduled: 0,
+                totalCancelled: 0,
+                cancellationRate: null,
+                avgWaitTime: null,
             };
         }
-        const closedEvents = this._eventList.filter((e) => e.action === "closed");
-        const totalClosed = closedEvents.length;
-        const winCount = closedEvents.filter((e) => e.pnl && e.pnl > 0).length;
-        const lossCount = closedEvents.filter((e) => e.pnl && e.pnl < 0).length;
-        // Calculate basic statistics
-        const avgPnl = totalClosed > 0
-            ? closedEvents.reduce((sum, e) => sum + (e.pnl || 0), 0) / totalClosed
-            : 0;
-        const totalPnl = closedEvents.reduce((sum, e) => sum + (e.pnl || 0), 0);
-        const winRate = (winCount / totalClosed) * 100;
-        // Calculate Sharpe Ratio (risk-free rate = 0)
-        let sharpeRatio = 0;
-        let stdDev = 0;
-        if (totalClosed > 0) {
-            const returns = closedEvents.map((e) => e.pnl || 0);
-            const variance = returns.reduce((sum, r) => sum + Math.pow(r - avgPnl, 2), 0) / totalClosed;
-            stdDev = Math.sqrt(variance);
-            sharpeRatio = stdDev > 0 ? avgPnl / stdDev : 0;
-        }
-        const annualizedSharpeRatio = sharpeRatio * Math.sqrt(365);
-        // Calculate Certainty Ratio
-        let certaintyRatio = 0;
-        if (totalClosed > 0) {
-            const wins = closedEvents.filter((e) => e.pnl && e.pnl > 0);
-            const losses = closedEvents.filter((e) => e.pnl && e.pnl < 0);
-            const avgWin = wins.length > 0
-                ? wins.reduce((sum, e) => sum + (e.pnl || 0), 0) / wins.length
-                : 0;
-            const avgLoss = losses.length > 0
-                ? losses.reduce((sum, e) => sum + (e.pnl || 0), 0) / losses.length
-                : 0;
-            certaintyRatio = avgLoss < 0 ? avgWin / Math.abs(avgLoss) : 0;
-        }
-        // Calculate Expected Yearly Returns
-        let expectedYearlyReturns = 0;
-        if (totalClosed > 0) {
-            const avgDurationMin = closedEvents.reduce((sum, e) => sum + (e.duration || 0), 0) / totalClosed;
-            const avgDurationDays = avgDurationMin / (60 * 24);
-            const tradesPerYear = avgDurationDays > 0 ? 365 / avgDurationDays : 0;
-            expectedYearlyReturns = avgPnl * tradesPerYear;
-        }
+        const scheduledEvents = this._eventList.filter((e) => e.action === "scheduled");
+        const cancelledEvents = this._eventList.filter((e) => e.action === "cancelled");
+        const totalScheduled = scheduledEvents.length;
+        const totalCancelled = cancelledEvents.length;
+        // Calculate cancellation rate
+        const cancellationRate = totalScheduled > 0 ? (totalCancelled / totalScheduled) * 100 : null;
+        // Calculate average wait time for cancelled signals
+        const avgWaitTime = totalCancelled > 0
+            ? cancelledEvents.reduce((sum, e) => sum + (e.duration || 0), 0) /
+                totalCancelled
+            : null;
         return {
             eventList: this._eventList,
             totalEvents: this._eventList.length,
-            totalClosed,
-            winCount,
-            lossCount,
-            winRate: isUnsafe$2(winRate) ? null : winRate,
-            avgPnl: isUnsafe$2(avgPnl) ? null : avgPnl,
-            totalPnl: isUnsafe$2(totalPnl) ? null : totalPnl,
-            stdDev: isUnsafe$2(stdDev) ? null : stdDev,
-            sharpeRatio: isUnsafe$2(sharpeRatio) ? null : sharpeRatio,
-            annualizedSharpeRatio: isUnsafe$2(annualizedSharpeRatio) ? null : annualizedSharpeRatio,
-            certaintyRatio: isUnsafe$2(certaintyRatio) ? null : certaintyRatio,
-            expectedYearlyReturns: isUnsafe$2(expectedYearlyReturns) ? null : expectedYearlyReturns,
+            totalScheduled,
+            totalCancelled,
+            cancellationRate,
+            avgWaitTime,
         };
     }
     /**
-     * Generates markdown report with all tick events for a strategy (View).
+     * Generates markdown report with all scheduled events for a strategy (View).
      *
      * @param strategyName - Strategy name
      * @returns Markdown formatted report with all events
@@ -4721,22 +6025,22 @@ let ReportStorage$1 = class ReportStorage {
     async getReport(strategyName) {
         const stats = await this.getData();
         if (stats.totalEvents === 0) {
-            return str.newline(`# Live Trading Report: ${strategyName}`, "", "No events recorded yet.");
+            return str.newline(`# Scheduled Signals Report: ${strategyName}`, "", "No scheduled signals recorded yet.");
         }
         const header = columns$1.map((col) => col.label);
         const separator = columns$1.map(() => "---");
         const rows = this._eventList.map((event) => columns$1.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
-        const table = str.newline(tableData.map(row => `| ${row.join(" | ")} |`));
-        return str.newline(`# Live Trading Report: ${strategyName}`, "", table, "", `**Total events:** ${stats.totalEvents}`, `**Closed signals:** ${stats.totalClosed}`, `**Win rate:** ${stats.winRate === null ? "N/A" : `${stats.winRate.toFixed(2)}% (${stats.winCount}W / ${stats.lossCount}L) (higher is better)`}`, `**Average PNL:** ${stats.avgPnl === null ? "N/A" : `${stats.avgPnl > 0 ? "+" : ""}${stats.avgPnl.toFixed(2)}% (higher is better)`}`, `**Total PNL:** ${stats.totalPnl === null ? "N/A" : `${stats.totalPnl > 0 ? "+" : ""}${stats.totalPnl.toFixed(2)}% (higher is better)`}`, `**Standard Deviation:** ${stats.stdDev === null ? "N/A" : `${stats.stdDev.toFixed(3)}% (lower is better)`}`, `**Sharpe Ratio:** ${stats.sharpeRatio === null ? "N/A" : `${stats.sharpeRatio.toFixed(3)} (higher is better)`}`, `**Annualized Sharpe Ratio:** ${stats.annualizedSharpeRatio === null ? "N/A" : `${stats.annualizedSharpeRatio.toFixed(3)} (higher is better)`}`, `**Certainty Ratio:** ${stats.certaintyRatio === null ? "N/A" : `${stats.certaintyRatio.toFixed(3)} (higher is better)`}`, `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better)`}`);
+        const table = str.newline(tableData.map((row) => `| ${row.join(" | ")} |`));
+        return str.newline(`# Scheduled Signals Report: ${strategyName}`, "", table, "", `**Total events:** ${stats.totalEvents}`, `**Scheduled signals:** ${stats.totalScheduled}`, `**Cancelled signals:** ${stats.totalCancelled}`, `**Cancellation rate:** ${stats.cancellationRate === null ? "N/A" : `${stats.cancellationRate.toFixed(2)}% (lower is better)`}`, `**Average wait time (cancelled):** ${stats.avgWaitTime === null ? "N/A" : `${stats.avgWaitTime.toFixed(2)} minutes`}`);
     }
     /**
      * Saves strategy report to disk.
      *
      * @param strategyName - Strategy name
-     * @param path - Directory path to save report (default: "./logs/live")
+     * @param path - Directory path to save report (default: "./logs/schedule")
      */
-    async dump(strategyName, path = "./logs/live") {
+    async dump(strategyName, path = "./logs/schedule") {
         const markdown = await this.getReport(strategyName);
         try {
             const dir = join(process.cwd(), path);
@@ -4744,7 +6048,7 @@ let ReportStorage$1 = class ReportStorage {
             const filename = `${strategyName}.md`;
             const filepath = join(dir, filename);
             await writeFile(filepath, markdown, "utf-8");
-            console.log(`Live trading report saved: ${filepath}`);
+            console.log(`Scheduled signals report saved: ${filepath}`);
         }
         catch (error) {
             console.error(`Failed to save markdown report:`, error);
@@ -4752,36 +6056,27 @@ let ReportStorage$1 = class ReportStorage {
     }
 };
 /**
- * Service for generating and saving live trading markdown reports.
+ * Service for generating and saving scheduled signals markdown reports.
  *
  * Features:
- * - Listens to all signal events via onTick callback
- * - Accumulates all events (idle, opened, active, closed) per strategy
+ * - Listens to scheduled and cancelled signal events via signalLiveEmitter
+ * - Accumulates all events (scheduled, cancelled) per strategy
  * - Generates markdown tables with detailed event information
- * - Provides trading statistics (win rate, average PNL)
- * - Saves reports to disk in logs/live/{strategyName}.md
+ * - Provides statistics (cancellation rate, average wait time)
+ * - Saves reports to disk in logs/schedule/{strategyName}.md
  *
  * @example
  * ```typescript
- * const service = new LiveMarkdownService();
+ * const service = new ScheduleMarkdownService();
  *
- * // Add to strategy callbacks
- * addStrategy({
- *   strategyName: "my-strategy",
- *   callbacks: {
- *     onTick: (symbol, result, backtest) => {
- *       if (!backtest) {
- *         service.tick(result);
- *       }
- *     }
- *   }
- * });
+ * // Service automatically subscribes to signalLiveEmitter on init
+ * // No manual callback setup needed
  *
  * // Later: generate and save report
  * await service.dump("my-strategy");
  * ```
  */
-class LiveMarkdownService {
+class ScheduleMarkdownService {
     constructor() {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
@@ -4791,46 +6086,33 @@ class LiveMarkdownService {
          */
         this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$1());
         /**
-         * Processes tick events and accumulates all event types.
-         * Should be called from IStrategyCallbacks.onTick.
+         * Processes tick events and accumulates scheduled/cancelled events.
+         * Should be called from signalLiveEmitter subscription.
          *
-         * Processes all event types: idle, opened, active, closed.
+         * Processes only scheduled and cancelled event types.
          *
          * @param data - Tick result from strategy execution
          *
          * @example
          * ```typescript
-         * const service = new LiveMarkdownService();
-         *
-         * callbacks: {
-         *   onTick: (symbol, result, backtest) => {
-         *     if (!backtest) {
-         *       service.tick(result);
-         *     }
-         *   }
-         * }
+         * const service = new ScheduleMarkdownService();
+         * // Service automatically subscribes in init()
          * ```
          */
         this.tick = async (data) => {
-            this.loggerService.log("liveMarkdownService tick", {
+            this.loggerService.log("scheduleMarkdownService tick", {
                 data,
             });
             const storage = this.getStorage(data.strategyName);
-            if (data.action === "idle") {
-                storage.addIdleEvent(data.currentPrice);
-            }
-            else if (data.action === "opened") {
-                storage.addOpenedEvent(data);
-            }
-            else if (data.action === "active") {
-                storage.addActiveEvent(data);
+            if (data.action === "scheduled") {
+                storage.addScheduledEvent(data);
             }
-            else if (data.action === "closed") {
-                storage.addClosedEvent(data);
+            else if (data.action === "cancelled") {
+                storage.addCancelledEvent(data);
             }
         };
         /**
-         * Gets statistical data from all live trading events for a strategy.
+         * Gets statistical data from all scheduled signal events for a strategy.
          * Delegates to ReportStorage.getData().
          *
          * @param strategyName - Strategy name to get data for
@@ -4838,20 +6120,20 @@ class LiveMarkdownService {
          *
          * @example
          * ```typescript
-         * const service = new LiveMarkdownService();
+         * const service = new ScheduleMarkdownService();
          * const stats = await service.getData("my-strategy");
-         * console.log(stats.sharpeRatio, stats.winRate);
+         * console.log(stats.cancellationRate, stats.avgWaitTime);
          * ```
          */
         this.getData = async (strategyName) => {
-            this.loggerService.log("liveMarkdownService getData", {
+            this.loggerService.log("scheduleMarkdownService getData", {
                 strategyName,
             });
             const storage = this.getStorage(strategyName);
             return storage.getData();
         };
         /**
-         * Generates markdown report with all events for a strategy.
+         * Generates markdown report with all scheduled events for a strategy.
          * Delegates to ReportStorage.getReport().
          *
          * @param strategyName - Strategy name to generate report for
@@ -4859,13 +6141,13 @@ class LiveMarkdownService {
          *
          * @example
          * ```typescript
-         * const service = new LiveMarkdownService();
+         * const service = new ScheduleMarkdownService();
          * const markdown = await service.getReport("my-strategy");
          * console.log(markdown);
          * ```
          */
         this.getReport = async (strategyName) => {
-            this.loggerService.log("liveMarkdownService getReport", {
+            this.loggerService.log("scheduleMarkdownService getReport", {
                 strategyName,
             });
             const storage = this.getStorage(strategyName);
@@ -4877,21 +6159,21 @@ class LiveMarkdownService {
          * Delegates to ReportStorage.dump().
          *
          * @param strategyName - Strategy name to save report for
-         * @param path - Directory path to save report (default: "./logs/live")
+         * @param path - Directory path to save report (default: "./logs/schedule")
          *
          * @example
          * ```typescript
-         * const service = new LiveMarkdownService();
+         * const service = new ScheduleMarkdownService();
          *
-         * // Save to default path: ./logs/live/my-strategy.md
+         * // Save to default path: ./logs/schedule/my-strategy.md
          * await service.dump("my-strategy");
          *
          * // Save to custom path: ./custom/path/my-strategy.md
          * await service.dump("my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (strategyName, path = "./logs/live") => {
-            this.loggerService.log("liveMarkdownService dump", {
+        this.dump = async (strategyName, path = "./logs/schedule") => {
+            this.loggerService.log("scheduleMarkdownService dump", {
                 strategyName,
                 path,
             });
@@ -4907,7 +6189,7 @@ class LiveMarkdownService {
          *
          * @example
          * ```typescript
-         * const service = new LiveMarkdownService();
+         * const service = new ScheduleMarkdownService();
          *
          * // Clear specific strategy data
          * await service.clear("my-strategy");
@@ -4917,7 +6199,7 @@ class LiveMarkdownService {
          * ```
          */
         this.clear = async (strategyName) => {
-            this.loggerService.log("liveMarkdownService clear", {
+            this.loggerService.log("scheduleMarkdownService clear", {
                 strategyName,
             });
             this.getStorage.clear(strategyName);
@@ -4929,13 +6211,13 @@ class LiveMarkdownService {
          *
          * @example
          * ```typescript
-         * const service = new LiveMarkdownService();
+         * const service = new ScheduleMarkdownService();
          * await service.init(); // Subscribe to live events
          * ```
          */
         this.init = singleshot(async () => {
-            this.loggerService.log("liveMarkdownService init");
-            signalLiveEmitter.subscribe(this.tick);
+            this.loggerService.log("scheduleMarkdownService init");
+            signalEmitter.subscribe(this.tick);
         });
     }
 }
@@ -6499,6 +7781,7 @@ class RiskValidationService {
 {
     provide(TYPES.backtestMarkdownService, () => new BacktestMarkdownService());
     provide(TYPES.liveMarkdownService, () => new LiveMarkdownService());
+    provide(TYPES.scheduleMarkdownService, () => new ScheduleMarkdownService());
     provide(TYPES.performanceMarkdownService, () => new PerformanceMarkdownService());
     provide(TYPES.walkerMarkdownService, () => new WalkerMarkdownService());
     provide(TYPES.heatMarkdownService, () => new HeatMarkdownService());
@@ -6557,6 +7840,7 @@ const logicPublicServices = {
 const markdownServices = {
     backtestMarkdownService: inject(TYPES.backtestMarkdownService),
     liveMarkdownService: inject(TYPES.liveMarkdownService),
+    scheduleMarkdownService: inject(TYPES.scheduleMarkdownService),
     performanceMarkdownService: inject(TYPES.performanceMarkdownService),
     walkerMarkdownService: inject(TYPES.walkerMarkdownService),
     heatMarkdownService: inject(TYPES.heatMarkdownService),
@@ -6603,6 +7887,20 @@ var backtest$1 = backtest;
 async function setLogger(logger) {
     backtest$1.loggerService.setLogger(logger);
 }
+/**
+ * Sets global configuration parameters for the framework.
+ * @param config - Partial configuration object to override default settings
+ *
+ * @example
+ * ```typescript
+ * setConfig({
+ *   CC_SCHEDULE_AWAIT_MINUTES: 90,
+ * });
+ * ```
+ */
+async function setConfig(config) {
+    Object.assign(GLOBAL_CONFIG, config);
+}
 
 const ADD_STRATEGY_METHOD_NAME = "add.addStrategy";
 const ADD_EXCHANGE_METHOD_NAME = "add.addExchange";
@@ -7885,8 +9183,17 @@ class BacktestUtils {
                 symbol,
                 context,
             });
-            backtest$1.backtestMarkdownService.clear(context.strategyName);
-            backtest$1.strategyGlobalService.clear(context.strategyName);
+            {
+                backtest$1.backtestMarkdownService.clear(context.strategyName);
+                backtest$1.scheduleMarkdownService.clear(context.strategyName);
+            }
+            {
+                backtest$1.strategyGlobalService.clear(context.strategyName);
+            }
+            {
+                const { riskName } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName && backtest$1.riskGlobalService.clear(riskName);
+            }
             return backtest$1.backtestGlobalService.run(symbol, context);
         };
         /**
@@ -8065,8 +9372,17 @@ class LiveUtils {
                 symbol,
                 context,
             });
-            backtest$1.liveMarkdownService.clear(context.strategyName);
-            backtest$1.strategyGlobalService.clear(context.strategyName);
+            {
+                backtest$1.liveMarkdownService.clear(context.strategyName);
+                backtest$1.scheduleMarkdownService.clear(context.strategyName);
+            }
+            {
+                backtest$1.strategyGlobalService.clear(context.strategyName);
+            }
+            {
+                const { riskName } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName && backtest$1.riskGlobalService.clear(riskName);
+            }
             return backtest$1.liveGlobalService.run(symbol, context);
         };
         /**
@@ -8192,6 +9508,132 @@ class LiveUtils {
  */
 const Live = new LiveUtils();
 
+const SCHEDULE_METHOD_NAME_GET_DATA = "ScheduleUtils.getData";
+const SCHEDULE_METHOD_NAME_GET_REPORT = "ScheduleUtils.getReport";
+const SCHEDULE_METHOD_NAME_DUMP = "ScheduleUtils.dump";
+const SCHEDULE_METHOD_NAME_CLEAR = "ScheduleUtils.clear";
+/**
+ * Utility class for scheduled signals reporting operations.
+ *
+ * Provides simplified access to scheduleMarkdownService with logging.
+ * Exported as singleton instance for convenient usage.
+ *
+ * Features:
+ * - Track scheduled signals in queue
+ * - Track cancelled signals
+ * - Calculate cancellation rate and average wait time
+ * - Generate markdown reports
+ *
+ * @example
+ * ```typescript
+ * import { Schedule } from "./classes/Schedule";
+ *
+ * // Get scheduled signals statistics
+ * const stats = await Schedule.getData("my-strategy");
+ * console.log(`Cancellation rate: ${stats.cancellationRate}%`);
+ * console.log(`Average wait time: ${stats.avgWaitTime} minutes`);
+ *
+ * // Generate and save report
+ * await Schedule.dump("my-strategy");
+ * ```
+ */
+class ScheduleUtils {
+    constructor() {
+        /**
+         * Gets statistical data from all scheduled signal events for a strategy.
+         *
+         * @param strategyName - Strategy name to get data for
+         * @returns Promise resolving to statistical data object
+         *
+         * @example
+         * ```typescript
+         * const stats = await Schedule.getData("my-strategy");
+         * console.log(stats.cancellationRate, stats.avgWaitTime);
+         * ```
+         */
+        this.getData = async (strategyName) => {
+            backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_GET_DATA, {
+                strategyName,
+            });
+            return await backtest$1.scheduleMarkdownService.getData(strategyName);
+        };
+        /**
+         * Generates markdown report with all scheduled events for a strategy.
+         *
+         * @param strategyName - Strategy name to generate report for
+         * @returns Promise resolving to markdown formatted report string
+         *
+         * @example
+         * ```typescript
+         * const markdown = await Schedule.getReport("my-strategy");
+         * console.log(markdown);
+         * ```
+         */
+        this.getReport = async (strategyName) => {
+            backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_GET_REPORT, {
+                strategyName,
+            });
+            return await backtest$1.scheduleMarkdownService.getReport(strategyName);
+        };
+        /**
+         * Saves strategy report to disk.
+         *
+         * @param strategyName - Strategy name to save report for
+         * @param path - Optional directory path to save report (default: "./logs/schedule")
+         *
+         * @example
+         * ```typescript
+         * // Save to default path: ./logs/schedule/my-strategy.md
+         * await Schedule.dump("my-strategy");
+         *
+         * // Save to custom path: ./custom/path/my-strategy.md
+         * await Schedule.dump("my-strategy", "./custom/path");
+         * ```
+         */
+        this.dump = async (strategyName, path) => {
+            backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_DUMP, {
+                strategyName,
+                path,
+            });
+            await backtest$1.scheduleMarkdownService.dump(strategyName, path);
+        };
+        /**
+         * Clears accumulated scheduled signal data from storage.
+         * If strategyName is provided, clears only that strategy's data.
+         * If strategyName is omitted, clears all strategies' data.
+         *
+         * @param strategyName - Optional strategy name to clear specific strategy data
+         *
+         * @example
+         * ```typescript
+         * // Clear specific strategy data
+         * await Schedule.clear("my-strategy");
+         *
+         * // Clear all strategies' data
+         * await Schedule.clear();
+         * ```
+         */
+        this.clear = async (strategyName) => {
+            backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_CLEAR, {
+                strategyName,
+            });
+            await backtest$1.scheduleMarkdownService.clear(strategyName);
+        };
+    }
+}
+/**
+ * Singleton instance of ScheduleUtils for convenient scheduled signals reporting.
+ *
+ * @example
+ * ```typescript
+ * import { Schedule } from "./classes/Schedule";
+ *
+ * const stats = await Schedule.getData("my-strategy");
+ * console.log("Cancellation rate:", stats.cancellationRate);
+ * ```
+ */
+const Schedule = new ScheduleUtils();
+
 /**
  * Performance class provides static methods for performance metrics analysis.
  *
@@ -8367,8 +9809,17 @@ class WalkerUtils {
             backtest$1.walkerMarkdownService.clear(context.walkerName);
             // Clear backtest data for all strategies
             for (const strategyName of walkerSchema.strategies) {
-                backtest$1.backtestMarkdownService.clear(strategyName);
-                backtest$1.strategyGlobalService.clear(strategyName);
+                {
+                    backtest$1.backtestMarkdownService.clear(strategyName);
+                    backtest$1.scheduleMarkdownService.clear(strategyName);
+                }
+                {
+                    backtest$1.strategyGlobalService.clear(strategyName);
+                }
+                {
+                    const { riskName } = backtest$1.strategySchemaService.get(strategyName);
+                    riskName && backtest$1.riskGlobalService.clear(riskName);
+                }
             }
             return backtest$1.walkerGlobalService.run(symbol, {
                 walkerName: context.walkerName,
@@ -8418,6 +9869,9 @@ class WalkerUtils {
             task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 isStopped = true;
+                for (const strategyName of walkerSchema.strategies) {
+                    backtest$1.strategyGlobalService.stop(strategyName);
+                }
             };
         };
         /**
@@ -8773,4 +10227,4 @@ PositionSizeUtils.atrBased = async (symbol, accountBalance, priceOpen, atr, cont
 };
 const PositionSize = PositionSizeUtils;
 
-export { Backtest, ExecutionContextService, Heat, Live, MethodContextService, Performance, PersistBase, PersistRiskAdapter, PersistSignalAdaper, PositionSize, Walker, addExchange, addFrame, addRisk, addSizing, addStrategy, addWalker, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listExchanges, listFrames, listRisks, listSizings, listStrategies, listWalkers, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenPerformance, listenProgress, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, setLogger };
+export { Backtest, ExecutionContextService, Heat, Live, MethodContextService, Performance, PersistBase, PersistRiskAdapter, PersistSignalAdapter, PositionSize, Schedule, Walker, addExchange, addFrame, addRisk, addSizing, addStrategy, addWalker, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getDate, getMode, backtest as lib, listExchanges, listFrames, listRisks, listSizings, listStrategies, listWalkers, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenPerformance, listenProgress, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, setConfig, setLogger };