backtest-kit 5.0.0 → 5.2.0

package/build/index.mjs

@@ -1,6 +1,6 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { Subject, makeExtendable, singleshot, getErrorMessage, memoize, not, errorData, trycatch, retry, queued, sleep, randomString, str, isObject, ToolRegistry, typo, and, Source, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, singlerun } from 'functools-kit';
+import { Subject, makeExtendable, singleshot, getErrorMessage, memoize, not, errorData, trycatch, retry, queued, sleep, randomString, str, isObject, ToolRegistry, typo, and, Source, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, BehaviorSubject, waitForNext, singlerun } from 'functools-kit';
 import * as fs from 'fs/promises';
 import fs__default, { stat, opendir, readFile } from 'fs/promises';
 import path, { join, dirname } from 'path';
@@ -69,6 +69,10 @@ const coreServices$1 = {
     actionCoreService: Symbol('actionCoreService'),
     frameCoreService: Symbol('frameCoreService'),
 };
+const metaServices$1 = {
+    priceMetaService: Symbol('priceMetaService'),
+    timeMetaService: Symbol('timeMetaService'),
+};
 const globalServices$1 = {
     sizingGlobalService: Symbol('sizingGlobalService'),
     riskGlobalService: Symbol('riskGlobalService'),
@@ -134,6 +138,7 @@ const TYPES = {
     ...connectionServices$1,
     ...schemaServices$1,
     ...coreServices$1,
+    ...metaServices$1,
     ...globalServices$1,
     ...commandServices$1,
     ...logicPrivateServices$1,
@@ -3538,19 +3543,6 @@ const beginTime = (run) => (...args) => {
     return fn();
 };
 
-/**
- * Retrieves the current timestamp for debugging purposes.
- * If an execution context is active (e.g., during a backtest), it returns the timestamp from the context to ensure consistency with the simulated time.
- * Can be empty (undefined) if not called from strategy async context, as it's intended for debugging and not critical for logic.
- * @return {number | undefined} The current timestamp in milliseconds from the execution context, or undefined if not available.
- */
-const getDebugTimestamp = () => {
-    if (ExecutionContextService.hasContext()) {
-        return bt.executionContextService.context.when.getTime();
-    }
-    return undefined;
-};
-
 const INTERVAL_MINUTES$6 = {
     "1m": 1,
     "3m": 3,
@@ -4258,7 +4250,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
                 pendingAt: currentTime, // Для immediate signal оба времени одинаковые
                 timestamp: currentTime,
                 _isScheduled: false,
-                _entry: [{ price: signal.priceOpen, cost: signal.cost ?? GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, debugTimestamp: currentTime }],
+                _entry: [{ price: signal.priceOpen, cost: signal.cost ?? GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, timestamp: currentTime }],
             };
             // Валидируем сигнал перед возвратом
             VALIDATE_SIGNAL_FN(signalRow, currentPrice, false);
@@ -4282,7 +4274,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
             pendingAt: SCHEDULED_SIGNAL_PENDING_MOCK, // Временно, обновится при активации
             timestamp: currentTime,
             _isScheduled: true,
-            _entry: [{ price: signal.priceOpen, cost: signal.cost ?? GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, debugTimestamp: currentTime }],
+            _entry: [{ price: signal.priceOpen, cost: signal.cost ?? GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, timestamp: currentTime }],
         };
         // Валидируем сигнал перед возвратом
         VALIDATE_SIGNAL_FN(scheduledSignalRow, currentPrice, true);
@@ -4302,7 +4294,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         pendingAt: currentTime, // Для immediate signal оба времени одинаковые
         timestamp: currentTime,
         _isScheduled: false,
-        _entry: [{ price: currentPrice, cost: signal.cost ?? GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, debugTimestamp: currentTime }],
+        _entry: [{ price: currentPrice, cost: signal.cost ?? GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, timestamp: currentTime }],
     };
     // Валидируем сигнал перед возвратом
     VALIDATE_SIGNAL_FN(signalRow, currentPrice, false);
@@ -4372,7 +4364,7 @@ const WAIT_FOR_DISPOSE_FN$1 = async (self) => {
     self.params.logger.debug("ClientStrategy dispose");
     await self.params.onDispose(self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName, self.params.method.context.frameName, self.params.execution.context.backtest);
 };
-const PARTIAL_PROFIT_FN = (self, signal, percentToClose, currentPrice) => {
+const PARTIAL_PROFIT_FN = (self, signal, percentToClose, currentPrice, timestamp) => {
     // Initialize partial array if not present
     if (!signal._partial)
         signal._partial = [];
@@ -4401,7 +4393,7 @@ const PARTIAL_PROFIT_FN = (self, signal, percentToClose, currentPrice) => {
         entryCountAtClose,
         currentPrice,
         costBasisAtClose: remainingCostBasis,
-        debugTimestamp: getDebugTimestamp(),
+        timestamp,
     });
     self.params.logger.info("PARTIAL_PROFIT_FN executed", {
         signalId: signal.id,
@@ -4411,7 +4403,7 @@ const PARTIAL_PROFIT_FN = (self, signal, percentToClose, currentPrice) => {
     });
     return true;
 };
-const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice) => {
+const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice, timestamp) => {
     // Initialize partial array if not present
     if (!signal._partial)
         signal._partial = [];
@@ -4439,7 +4431,7 @@ const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice) => {
         currentPrice,
         entryCountAtClose,
         costBasisAtClose: remainingCostBasis,
-        debugTimestamp: getDebugTimestamp(),
+        timestamp,
     });
     self.params.logger.warn("PARTIAL_LOSS_FN executed", {
         signalId: signal.id,
@@ -4836,10 +4828,10 @@ const BREAKEVEN_FN = (self, signal, currentPrice) => {
     });
     return true;
 };
-const AVERAGE_BUY_FN = (self, signal, currentPrice, cost = GLOBAL_CONFIG.CC_POSITION_ENTRY_COST) => {
+const AVERAGE_BUY_FN = (self, signal, currentPrice, timestamp, cost = GLOBAL_CONFIG.CC_POSITION_ENTRY_COST) => {
     // Ensure _entry is initialized (handles signals loaded from disk without _entry)
     if (!signal._entry || signal._entry.length === 0) {
-        signal._entry = [{ price: signal.priceOpen, cost: GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, debugTimestamp: getDebugTimestamp() }];
+        signal._entry = [{ price: signal.priceOpen, cost: GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, timestamp }];
     }
     if (signal.position === "long") {
         // LONG: new entry must beat the all-time low — strictly below every prior entry price
@@ -4869,7 +4861,7 @@ const AVERAGE_BUY_FN = (self, signal, currentPrice, cost = GLOBAL_CONFIG.CC_POSI
             return false;
         }
     }
-    signal._entry.push({ price: currentPrice, cost, debugTimestamp: getDebugTimestamp() });
+    signal._entry.push({ price: currentPrice, cost, timestamp });
     self.params.logger.info("AVERAGE_BUY_FN executed", {
         signalId: signal.id,
         position: signal.position,
@@ -5052,7 +5044,7 @@ const CALL_SCHEDULE_PING_CALLBACKS_FN = trycatch(beginTime(async (self, symbol,
     await ExecutionContextService.runInContext(async () => {
         const publicSignal = TO_PUBLIC_SIGNAL(scheduled, currentPrice);
         // Call system onSchedulePing callback first (emits to pingSubject)
-        await self.params.onSchedulePing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, publicSignal, self.params.execution.context.backtest, timestamp);
+        await self.params.onSchedulePing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, publicSignal, currentPrice, self.params.execution.context.backtest, timestamp);
         // Call user onSchedulePing callback only if signal is still active (not cancelled, not activated)
         if (self.params.callbacks?.onSchedulePing) {
             await self.params.callbacks.onSchedulePing(self.params.execution.context.symbol, publicSignal, new Date(timestamp), self.params.execution.context.backtest);
@@ -5078,7 +5070,7 @@ const CALL_ACTIVE_PING_CALLBACKS_FN = trycatch(beginTime(async (self, symbol, pe
     await ExecutionContextService.runInContext(async () => {
         const publicSignal = TO_PUBLIC_SIGNAL(pending, currentPrice);
         // Call system onActivePing callback first (emits to activePingSubject)
-        await self.params.onActivePing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, publicSignal, self.params.execution.context.backtest, timestamp);
+        await self.params.onActivePing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, publicSignal, currentPrice, self.params.execution.context.backtest, timestamp);
         // Call user onActivePing callback only if signal is still active (not closed)
         if (self.params.callbacks?.onActivePing) {
             await self.params.callbacks.onActivePing(self.params.execution.context.symbol, publicSignal, new Date(timestamp), self.params.execution.context.backtest);
@@ -5876,6 +5868,57 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
     await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
     return result;
 };
+const CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, closedSignal, averagePrice, closeTimestamp) => {
+    const syncCloseAllowed = await CALL_SIGNAL_SYNC_CLOSE_FN(closeTimestamp, averagePrice, "closed", closedSignal, self);
+    if (!syncCloseAllowed) {
+        self.params.logger.info("ClientStrategy backtest: user-closed signal rejected by sync, will retry", {
+            symbol: self.params.execution.context.symbol,
+            signalId: closedSignal.id,
+        });
+        self._closedSignal = null;
+        self._pendingSignal = closedSignal;
+        throw new Error(`ClientStrategy backtest: signal close rejected by sync (signalId=${closedSignal.id}). ` +
+            `Retry backtest() with new candle data.`);
+    }
+    self._closedSignal = null;
+    await CALL_COMMIT_FN(self, {
+        action: "close-pending",
+        symbol: self.params.execution.context.symbol,
+        strategyName: self.params.strategyName,
+        exchangeName: self.params.exchangeName,
+        frameName: self.params.frameName,
+        signalId: closedSignal.id,
+        backtest: true,
+        closeId: closedSignal.closeId,
+        timestamp: closeTimestamp,
+        totalEntries: closedSignal._entry?.length ?? 1,
+        totalPartials: closedSignal._partial?.length ?? 0,
+        originalPriceOpen: closedSignal.priceOpen,
+        pnl: toProfitLossDto(closedSignal, averagePrice),
+    });
+    await CALL_CLOSE_CALLBACKS_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
+    await CALL_PARTIAL_CLEAR_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
+    await CALL_BREAKEVEN_CLEAR_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
+    await CALL_RISK_REMOVE_SIGNAL_FN(self, self.params.execution.context.symbol, closeTimestamp, self.params.execution.context.backtest);
+    const pnl = toProfitLossDto(closedSignal, averagePrice);
+    const result = {
+        action: "closed",
+        signal: TO_PUBLIC_SIGNAL(closedSignal, averagePrice),
+        currentPrice: averagePrice,
+        closeReason: "closed",
+        closeTimestamp,
+        pnl,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
+        symbol: self.params.execution.context.symbol,
+        backtest: self.params.execution.context.backtest,
+        closeId: closedSignal.closeId,
+        createdAt: closeTimestamp,
+    };
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
+    return result;
+};
 const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) => {
     const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
     const maxTimeToWait = GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES * 60 * 1000;
@@ -5893,7 +5936,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
         if (self._cancelledSignal) {
             // Сигнал был отменен через cancel() в onSchedulePing
             const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "user");
-            return { activated: false, cancelled: true, activationIndex: i, result };
+            return { outcome: "cancelled", result };
         }
         // КРИТИЧНО: Проверяем был ли сигнал активирован пользователем через activateScheduled()
         // Обрабатываем inline (как в tick()) с риск-проверкой по averagePrice
@@ -5907,7 +5950,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                     signalId: activatedSignal.id,
                 });
                 await self.setScheduledSignal(null);
-                return { activated: false, cancelled: false, activationIndex: i, result: null };
+                return { outcome: "pending" };
             }
             // Риск-проверка по averagePrice (симметрия с LIVE tick())
             if (await not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, activatedSignal, averagePrice, candle.timestamp, self.params.execution.context.backtest))) {
@@ -5916,7 +5959,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                     signalId: activatedSignal.id,
                 });
                 await self.setScheduledSignal(null);
-                return { activated: false, cancelled: false, activationIndex: i, result: null };
+                return { outcome: "pending" };
             }
             const pendingSignal = {
                 ...activatedSignal,
@@ -5945,7 +5988,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                     originalPriceOpen: activatedSignal.priceOpen,
                     pnl: toProfitLossDto(activatedSignal, averagePrice),
                 });
-                return { activated: false, cancelled: true, activationIndex: i, result: null };
+                return { outcome: "pending" };
             }
             await self.setScheduledSignal(null);
             await self.setPendingSignal(pendingSignal);
@@ -5978,18 +6021,13 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
             });
             await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, pendingSignal, pendingSignal.priceOpen, candle.timestamp, self.params.execution.context.backtest);
             await CALL_BACKTEST_SCHEDULE_OPEN_FN(self, self.params.execution.context.symbol, pendingSignal, candle.timestamp, self.params.execution.context.backtest);
-            return {
-                activated: true,
-                cancelled: false,
-                activationIndex: i,
-                result: null,
-            };
+            return { outcome: "activated", activationIndex: i };
         }
         // КРИТИЧНО: Проверяем timeout ПЕРЕД проверкой цены
         const elapsedTime = candle.timestamp - scheduled.scheduledAt;
         if (elapsedTime >= maxTimeToWait) {
             const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "timeout");
-            return { activated: false, cancelled: true, activationIndex: i, result };
+            return { outcome: "cancelled", result };
         }
         let shouldActivate = false;
         let shouldCancel = false;
@@ -6027,27 +6065,17 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
         }
         if (shouldCancel) {
             const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "price_reject");
-            return { activated: false, cancelled: true, activationIndex: i, result };
+            return { outcome: "cancelled", result };
         }
         if (shouldActivate) {
             await ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, candle.timestamp);
-            return {
-                activated: true,
-                cancelled: false,
-                activationIndex: i,
-                result: null,
-            };
+            return { outcome: "activated", activationIndex: i };
         }
         await CALL_SCHEDULE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, candle.timestamp, true, averagePrice);
         // Process queued commit events with candle timestamp
         await PROCESS_COMMIT_QUEUE_FN(self, averagePrice, candle.timestamp);
     }
-    return {
-        activated: false,
-        cancelled: false,
-        activationIndex: -1,
-        result: null,
-    };
+    return { outcome: "pending" };
 };
 const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
     const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
@@ -6066,6 +6094,10 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         const startIndex = Math.max(0, i - (candlesCount - 1));
         const recentCandles = candles.slice(startIndex, i + 1);
         const averagePrice = GET_AVG_PRICE_FN(recentCandles);
+        // КРИТИЧНО: Проверяем был ли сигнал закрыт пользователем через closePending()
+        if (self._closedSignal) {
+            return await CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN(self, self._closedSignal, averagePrice, currentCandleTimestamp);
+        }
         await CALL_ACTIVE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentCandleTimestamp, true, averagePrice);
         let shouldClose = false;
         let closeReason;
@@ -6170,7 +6202,32 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         // Process queued commit events with candle timestamp
         await PROCESS_COMMIT_QUEUE_FN(self, averagePrice, currentCandleTimestamp);
     }
-    return null;
+    // Loop exhausted without closing — check if we have enough data
+    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;
+    const signalTime = signal.pendingAt;
+    const maxTimeToWait = signal.minuteEstimatedTime * 60 * 1000;
+    const elapsedTime = closeTimestamp - signalTime;
+    if (elapsedTime < maxTimeToWait) {
+        const bufferCandlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
+        const requiredCandlesCount = signal.minuteEstimatedTime + bufferCandlesCount + 1;
+        throw new Error(str.newline(`ClientStrategy backtest: Insufficient candle data for pending signal. ` +
+            `Signal opened at ${new Date(signal.pendingAt).toISOString()}, ` +
+            `last candle at ${new Date(closeTimestamp).toISOString()}. ` +
+            `Elapsed: ${Math.floor(elapsedTime / 60000)}min of ${signal.minuteEstimatedTime}min required. ` +
+            `Provided ${candles.length} candles, but need at least ${requiredCandlesCount} candles. ` +
+            `\nBreakdown: ${signal.minuteEstimatedTime} candles for signal lifetime + ${bufferCandlesCount} buffer candles. ` +
+            `\nBuffer explanation: VWAP calculation requires ${GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT} candles, ` +
+            `so first ${bufferCandlesCount} candles are skipped to ensure accurate price averaging. ` +
+            `Provide complete candle range: [pendingAt - ${bufferCandlesCount}min, pendingAt + ${signal.minuteEstimatedTime}min].`));
+    }
+    const timeExpiredResult = await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(self, signal, lastPrice, "time_expired", closeTimestamp);
+    if (!timeExpiredResult) {
+        throw new Error(`ClientStrategy backtest: time_expired close rejected by sync (signalId=${signal.id}). ` +
+            `Retry backtest() with new candle data.`);
+    }
+    return timeExpiredResult;
 };
 /**
  * Client implementation for trading strategy lifecycle management.
@@ -6654,16 +6711,16 @@ class ClientStrategy {
      * // No DCA: [{ price: 43000, cost: 100 }]
      * // One DCA: [{ price: 43000, cost: 100 }, { price: 42000, cost: 100 }]
      */
-    async getPositionEntries(symbol) {
+    async getPositionEntries(symbol, timestamp) {
         this.params.logger.debug("ClientStrategy getPositionEntries", { symbol });
         if (!this._pendingSignal) {
             return null;
         }
         const entries = this._pendingSignal._entry;
         if (!entries || entries.length === 0) {
-            return [{ price: this._pendingSignal.priceOpen, cost: GLOBAL_CONFIG.CC_POSITION_ENTRY_COST }];
+            return [{ price: this._pendingSignal.priceOpen, cost: GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, timestamp }];
         }
-        return entries.map(({ price, cost }) => ({ price, cost }));
+        return entries.map(({ price, cost, timestamp }) => ({ price, cost, timestamp }));
     }
     /**
      * Performs a single tick of strategy execution.
@@ -7117,11 +7174,12 @@ class ClientStrategy {
                 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;
+            const scheduledResult = await PROCESS_SCHEDULED_SIGNAL_CANDLES_FN(this, scheduled, candles);
+            if (scheduledResult.outcome === "cancelled") {
+                return scheduledResult.result;
             }
-            if (activated) {
+            if (scheduledResult.outcome === "activated") {
+                const { activationIndex } = scheduledResult;
                 // КРИТИЧНО: activationIndex - индекс свечи активации в массиве candles
                 // BacktestLogicPrivateService включил буфер в начало массива, поэтому перед activationIndex достаточно свечей
                 // PROCESS_PENDING_SIGNAL_CANDLES_FN пропустит первые bufferCandlesCount свечей для VWAP
@@ -7193,40 +7251,7 @@ class ClientStrategy {
         if (candles.length < candlesCount) {
             this.params.logger.warn(`ClientStrategy backtest: Expected at least ${candlesCount} candles for VWAP, got ${candles.length}`);
         }
-        const closedResult = await PROCESS_PENDING_SIGNAL_CANDLES_FN(this, signal, candles);
-        if (closedResult) {
-            return closedResult;
-        }
-        // Signal didn't close during candle processing - check if we have enough data
-        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;
-        const signalTime = signal.pendingAt;
-        const maxTimeToWait = signal.minuteEstimatedTime * 60 * 1000;
-        const elapsedTime = closeTimestamp - signalTime;
-        // Check if we actually reached time expiration or just ran out of candles
-        if (elapsedTime < maxTimeToWait) {
-            // EDGE CASE: backtest() called with insufficient candle data
-            const bufferCandlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
-            const requiredCandlesCount = signal.minuteEstimatedTime + bufferCandlesCount + 1;
-            throw new Error(str.newline(`ClientStrategy backtest: Insufficient candle data for pending signal. ` +
-                `Signal opened at ${new Date(signal.pendingAt).toISOString()}, ` +
-                `last candle at ${new Date(closeTimestamp).toISOString()}. ` +
-                `Elapsed: ${Math.floor(elapsedTime / 60000)}min of ${signal.minuteEstimatedTime}min required. ` +
-                `Provided ${candles.length} candles, but need at least ${requiredCandlesCount} candles. ` +
-                `\nBreakdown: ${signal.minuteEstimatedTime} candles for signal lifetime + ${bufferCandlesCount} buffer candles. ` +
-                `\nBuffer explanation: VWAP calculation requires ${GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT} candles, ` +
-                `so first ${bufferCandlesCount} candles are skipped to ensure accurate price averaging. ` +
-                `Provide complete candle range: [pendingAt - ${bufferCandlesCount}min, pendingAt + ${signal.minuteEstimatedTime}min].`));
-        }
-        // Time actually expired - close with time_expired
-        const timeExpiredResult = await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(this, signal, lastPrice, "time_expired", closeTimestamp);
-        if (!timeExpiredResult) {
-            // Sync rejected the close — signal remains in _pendingSignal, caller must retry
-            throw new Error(`ClientStrategy backtest: time_expired close rejected by sync (signalId=${signal.id}). ` +
-                `Retry backtest() with new candle data.`);
-        }
-        return timeExpiredResult;
+        return await PROCESS_PENDING_SIGNAL_CANDLES_FN(this, signal, candles);
     }
     /**
      * Stops the strategy from generating new signals.
@@ -7499,7 +7524,7 @@ class ClientStrategy {
      * // success3 = false (skipped, would exceed 100%)
      * ```
      */
-    async partialProfit(symbol, percentToClose, currentPrice, backtest) {
+    async partialProfit(symbol, percentToClose, currentPrice, backtest, timestamp) {
         this.params.logger.debug("ClientStrategy partialProfit", {
             symbol,
             percentToClose,
@@ -7563,7 +7588,7 @@ class ClientStrategy {
             return false;
         }
         // Execute partial close logic
-        const wasExecuted = PARTIAL_PROFIT_FN(this, this._pendingSignal, percentToClose, currentPrice);
+        const wasExecuted = PARTIAL_PROFIT_FN(this, this._pendingSignal, percentToClose, currentPrice, timestamp);
         // If partial was not executed (exceeded 100%), return false without persistence
         if (!wasExecuted) {
             return false;
@@ -7682,7 +7707,7 @@ class ClientStrategy {
      * // success3 = false (skipped, would exceed 100%)
      * ```
      */
-    async partialLoss(symbol, percentToClose, currentPrice, backtest) {
+    async partialLoss(symbol, percentToClose, currentPrice, backtest, timestamp) {
         this.params.logger.debug("ClientStrategy partialLoss", {
             symbol,
             percentToClose,
@@ -7746,7 +7771,7 @@ class ClientStrategy {
             return false;
         }
         // Execute partial close logic
-        const wasExecuted = PARTIAL_LOSS_FN(this, this._pendingSignal, percentToClose, currentPrice);
+        const wasExecuted = PARTIAL_LOSS_FN(this, this._pendingSignal, percentToClose, currentPrice, timestamp);
         // If partial was not executed (exceeded 100%), return false without persistence
         if (!wasExecuted) {
             return false;
@@ -8502,7 +8527,7 @@ class ClientStrategy {
      * @param backtest - Whether running in backtest mode
      * @returns Promise<boolean> - true if entry added, false if rejected by direction check
      */
-    async averageBuy(symbol, currentPrice, backtest, cost = GLOBAL_CONFIG.CC_POSITION_ENTRY_COST) {
+    async averageBuy(symbol, currentPrice, backtest, timestamp, cost = GLOBAL_CONFIG.CC_POSITION_ENTRY_COST) {
         this.params.logger.debug("ClientStrategy averageBuy", {
             symbol,
             currentPrice,
@@ -8517,7 +8542,7 @@ class ClientStrategy {
             throw new Error(`ClientStrategy averageBuy: currentPrice must be a positive finite number, got ${currentPrice}`);
         }
         // Execute averaging logic
-        const result = AVERAGE_BUY_FN(this, this._pendingSignal, currentPrice, cost);
+        const result = AVERAGE_BUY_FN(this, this._pendingSignal, currentPrice, timestamp, cost);
         if (!result) {
             return false;
         }
@@ -8981,7 +9006,7 @@ const GET_RISK_FN = (dto, backtest, exchangeName, frameName, self) => {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$m = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$o = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -8997,11 +9022,12 @@ const CREATE_KEY_FN$m = (symbol, strategyName, exchangeName, frameName, backtest
  * @param self - Reference to StrategyConnectionService instance
  * @returns Callback function for schedule ping events
  */
-const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => trycatch(async (symbol, strategyName, exchangeName, data, backtest, timestamp) => {
+const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => trycatch(async (symbol, strategyName, exchangeName, data, currentPrice, backtest, timestamp) => {
     const event = {
         symbol,
         strategyName,
         exchangeName,
+        currentPrice,
         data,
         backtest,
         timestamp,
@@ -9030,11 +9056,12 @@ const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => trycatch(async (symbol, strateg
  * @param self - Reference to StrategyConnectionService instance
  * @returns Callback function for active ping events
  */
-const CREATE_COMMIT_ACTIVE_PING_FN = (self) => trycatch(async (symbol, strategyName, exchangeName, data, backtest, timestamp) => {
+const CREATE_COMMIT_ACTIVE_PING_FN = (self) => trycatch(async (symbol, strategyName, exchangeName, data, currentPrice, backtest, timestamp) => {
     const event = {
         symbol,
         strategyName,
         exchangeName,
+        currentPrice,
         data,
         backtest,
         timestamp,
@@ -9158,6 +9185,8 @@ class StrategyConnectionService {
         this.partialConnectionService = inject(TYPES.partialConnectionService);
         this.breakevenConnectionService = inject(TYPES.breakevenConnectionService);
         this.actionCoreService = inject(TYPES.actionCoreService);
+        this.timeMetaService = inject(TYPES.timeMetaService);
+        this.priceMetaService = inject(TYPES.priceMetaService);
         /**
          * Retrieves memoized ClientStrategy instance for given symbol-strategy pair with exchange and frame isolation.
          *
@@ -9171,7 +9200,7 @@ class StrategyConnectionService {
          * @param backtest - Whether running in backtest mode
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$m(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
+        this.getStrategy = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$o(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
             const { riskName = "", riskList = [], getSignal, interval, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
@@ -9258,6 +9287,20 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.getTotalCostClosed(symbol);
         };
+        /**
+         * Returns the effective (DCA-averaged) entry price for the current pending signal.
+         *
+         * This is the harmonic mean of all _entry prices, which is the correct
+         * cost-basis price used in all PNL calculations.
+         * With no DCA entries, equals the original priceOpen.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to effective entry price or null
+         */
         this.getPositionAveragePrice = async (backtest, symbol, context) => {
             this.loggerService.log("strategyConnectionService getPositionAveragePrice", {
                 symbol,
@@ -9267,6 +9310,19 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.getPositionAveragePrice(symbol);
         };
+        /**
+         * Returns the number of DCA entries made for the current pending signal.
+         *
+         * 1 = original entry only (no DCA).
+         * Increases by 1 with each successful commitAverageBuy().
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to entry count or null
+         */
         this.getPositionInvestedCount = async (backtest, symbol, context) => {
             this.loggerService.log("strategyConnectionService getPositionInvestedCount", {
                 symbol,
@@ -9276,6 +9332,19 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.getPositionInvestedCount(symbol);
         };
+        /**
+         * Returns the total invested cost basis in dollars for the current pending signal.
+         *
+         * Equal to entryCount × $100 (COST_BASIS_PER_ENTRY).
+         * 1 entry = $100, 2 entries = $200, etc.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to total invested cost in dollars or null
+         */
         this.getPositionInvestedCost = async (backtest, symbol, context) => {
             this.loggerService.log("strategyConnectionService getPositionInvestedCost", {
                 symbol,
@@ -9285,6 +9354,20 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.getPositionInvestedCost(symbol);
         };
+        /**
+         * Returns the unrealized PNL percentage for the current pending signal at currentPrice.
+         *
+         * Accounts for partial closes, DCA entries, slippage and fees
+         * (delegates to toProfitLossDto).
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to pnlPercentage or null
+         */
         this.getPositionPnlPercent = async (backtest, symbol, currentPrice, context) => {
             this.loggerService.log("strategyConnectionService getPositionPnlPercent", {
                 symbol,
@@ -9295,6 +9378,20 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.getPositionPnlPercent(symbol, currentPrice);
         };
+        /**
+         * Returns the unrealized PNL in dollars for the current pending signal at currentPrice.
+         *
+         * Calculated as: pnlPercentage / 100 × totalInvestedCost
+         * Accounts for partial closes, DCA entries, slippage and fees.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to pnl in dollars or null
+         */
         this.getPositionPnlCost = async (backtest, symbol, currentPrice, context) => {
             this.loggerService.log("strategyConnectionService getPositionPnlCost", {
                 symbol,
@@ -9305,6 +9402,27 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.getPositionPnlCost(symbol, currentPrice);
         };
+        /**
+         * Returns the list of DCA entry prices for the current pending signal.
+         *
+         * The first element is always the original priceOpen (initial entry).
+         * Each subsequent element is a price added by commitAverageBuy().
+         *
+         * Returns null if no pending signal exists.
+         * Returns a single-element array [priceOpen] if no DCA entries were made.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to array of entry prices or null
+         *
+         * @example
+         * ```typescript
+         * // No DCA: [43000]
+         * // One DCA: [43000, 42000]
+         * // Two DCA: [43000, 42000, 41500]
+         * ```
+         */
         this.getPositionLevels = async (backtest, symbol, context) => {
             this.loggerService.log("strategyConnectionService getPositionLevels", {
                 symbol,
@@ -9314,6 +9432,20 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.getPositionLevels(symbol);
         };
+        /**
+         * Returns the list of partial closes for the current pending signal.
+         *
+         * Each entry records a partial profit or loss close event with its type,
+         * percent closed, price at close, cost basis snapshot, and entry count at close.
+         *
+         * Returns null if no pending signal exists.
+         * Returns an empty array if no partial closes have been executed.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to array of partial close records or null
+         */
         this.getPositionPartials = async (backtest, symbol, context) => {
             this.loggerService.log("strategyConnectionService getPositionPartials", {
                 symbol,
@@ -9323,6 +9455,27 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.getPositionPartials(symbol);
         };
+        /**
+         * Returns the list of DCA entry prices and costs for the current pending signal.
+         *
+         * Each entry records the price and cost of a single position entry.
+         * The first element is always the original priceOpen (initial entry).
+         * Each subsequent element is an entry added by averageBuy().
+         *
+         * Returns null if no pending signal exists.
+         * Returns a single-element array [{ price: priceOpen, cost }] if no DCA entries were made.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to array of entry records or null
+         *
+         * @example
+         * ```typescript
+         * // No DCA: [{ price: 43000, cost: 100 }]
+         * // One DCA: [{ price: 43000, cost: 100 }, { price: 42000, cost: 100 }]
+         * ```
+         */
         this.getPositionEntries = async (backtest, symbol, context) => {
             this.loggerService.log("strategyConnectionService getPositionEntries", {
                 symbol,
@@ -9330,7 +9483,8 @@ class StrategyConnectionService {
                 backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            return await strategy.getPositionEntries(symbol);
+            const timestamp = await this.timeMetaService.getTimestamp(symbol, context, backtest);
+            return await strategy.getPositionEntries(symbol, timestamp);
         };
         /**
          * Retrieves the currently active scheduled signal for the strategy.
@@ -9432,6 +9586,10 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             await strategy.waitForInit();
             const tick = await strategy.tick(symbol, context.strategyName);
+            {
+                this.priceMetaService.next(symbol, tick.currentPrice, context, backtest);
+                this.timeMetaService.next(symbol, tick.createdAt, context, backtest);
+            }
             {
                 await CALL_SIGNAL_EMIT_FN(this, tick, context, backtest, symbol);
             }
@@ -9538,7 +9696,7 @@ class StrategyConnectionService {
                 }
                 return;
             }
-            const key = CREATE_KEY_FN$m(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$o(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             if (!this.getStrategy.has(key)) {
                 return;
             }
@@ -9607,9 +9765,9 @@ class StrategyConnectionService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise<boolean> - true if `partialProfit` would execute, false otherwise
          */
-        this.validatePartialProfit = (backtest, symbol, percentToClose, currentPrice, context) => {
+        this.validatePartialProfit = async (backtest, symbol, percentToClose, currentPrice, context) => {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            return Promise.resolve(strategy.validatePartialProfit(symbol, percentToClose, currentPrice));
+            return await strategy.validatePartialProfit(symbol, percentToClose, currentPrice);
         };
         /**
          * Executes partial close at profit level (moving toward TP).
@@ -9650,7 +9808,8 @@ class StrategyConnectionService {
                 backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            return await strategy.partialProfit(symbol, percentToClose, currentPrice, backtest);
+            const timestamp = await this.timeMetaService.getTimestamp(symbol, context, backtest);
+            return await strategy.partialProfit(symbol, percentToClose, currentPrice, backtest, timestamp);
         };
         /**
          * Checks whether `partialLoss` would succeed without executing it.
@@ -9663,9 +9822,9 @@ class StrategyConnectionService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise<boolean> - true if `partialLoss` would execute, false otherwise
          */
-        this.validatePartialLoss = (backtest, symbol, percentToClose, currentPrice, context) => {
+        this.validatePartialLoss = async (backtest, symbol, percentToClose, currentPrice, context) => {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            return Promise.resolve(strategy.validatePartialLoss(symbol, percentToClose, currentPrice));
+            return await strategy.validatePartialLoss(symbol, percentToClose, currentPrice);
         };
         /**
          * Executes partial close at loss level (moving toward SL).
@@ -9706,7 +9865,8 @@ class StrategyConnectionService {
                 backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            return await strategy.partialLoss(symbol, percentToClose, currentPrice, backtest);
+            const timestamp = await this.timeMetaService.getTimestamp(symbol, context, backtest);
+            return await strategy.partialLoss(symbol, percentToClose, currentPrice, backtest, timestamp);
         };
         /**
          * Checks whether `trailingStop` would succeed without executing it.
@@ -9719,9 +9879,9 @@ class StrategyConnectionService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise<boolean> - true if `trailingStop` would execute, false otherwise
          */
-        this.validateTrailingStop = (backtest, symbol, percentShift, currentPrice, context) => {
+        this.validateTrailingStop = async (backtest, symbol, percentShift, currentPrice, context) => {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            return Promise.resolve(strategy.validateTrailingStop(symbol, percentShift, currentPrice));
+            return await strategy.validateTrailingStop(symbol, percentShift, currentPrice);
         };
         /**
          * Adjusts the trailing stop-loss distance for an active pending signal.
@@ -9773,9 +9933,9 @@ class StrategyConnectionService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise<boolean> - true if `trailingTake` would execute, false otherwise
          */
-        this.validateTrailingTake = (backtest, symbol, percentShift, currentPrice, context) => {
+        this.validateTrailingTake = async (backtest, symbol, percentShift, currentPrice, context) => {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            return Promise.resolve(strategy.validateTrailingTake(symbol, percentShift, currentPrice));
+            return await strategy.validateTrailingTake(symbol, percentShift, currentPrice);
         };
         /**
          * Adjusts the trailing take-profit distance for an active pending signal.
@@ -9826,9 +9986,9 @@ class StrategyConnectionService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise<boolean> - true if `breakeven` would execute, false otherwise
          */
-        this.validateBreakeven = (backtest, symbol, currentPrice, context) => {
+        this.validateBreakeven = async (backtest, symbol, currentPrice, context) => {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            return Promise.resolve(strategy.validateBreakeven(symbol, currentPrice));
+            return await strategy.validateBreakeven(symbol, currentPrice);
         };
         /**
          * Delegates to ClientStrategy.breakeven() with current execution context.
@@ -9905,9 +10065,9 @@ class StrategyConnectionService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise<boolean> - true if `averageBuy` would execute, false otherwise
          */
-        this.validateAverageBuy = (backtest, symbol, currentPrice, context) => {
+        this.validateAverageBuy = async (backtest, symbol, currentPrice, context) => {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            return Promise.resolve(strategy.validateAverageBuy(symbol, currentPrice));
+            return await strategy.validateAverageBuy(symbol, currentPrice);
         };
         /**
          * Adds a new DCA entry to the active pending signal.
@@ -9928,7 +10088,8 @@ class StrategyConnectionService {
                 backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            return await strategy.averageBuy(symbol, currentPrice, backtest, cost);
+            const timestamp = await this.timeMetaService.getTimestamp(symbol, context, backtest);
+            return await strategy.averageBuy(symbol, currentPrice, backtest, timestamp, cost);
         };
     }
 }
@@ -10669,7 +10830,7 @@ class ClientRisk {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$l = (riskName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$n = (riskName, exchangeName, frameName, backtest) => {
     const parts = [riskName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -10768,7 +10929,7 @@ class RiskConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientRisk instance
          */
-        this.getRisk = memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$l(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
+        this.getRisk = memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$n(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
             const schema = this.riskSchemaService.get(riskName);
             return new ClientRisk({
                 ...schema,
@@ -10836,7 +10997,7 @@ class RiskConnectionService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$l(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$n(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getRisk.clear(key);
             }
             else {
@@ -12303,7 +12464,7 @@ class ClientAction {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$k = (actionName, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$m = (actionName, strategyName, exchangeName, frameName, backtest) => {
     const parts = [actionName, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -12354,7 +12515,7 @@ class ActionConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientAction instance
          */
-        this.getAction = memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$k(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
+        this.getAction = memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$m(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
             const schema = this.actionSchemaService.get(actionName);
             return new ClientAction({
                 ...schema,
@@ -12564,7 +12725,7 @@ class ActionConnectionService {
                 await Promise.all(actions.map(async (action) => await action.dispose()));
                 return;
             }
-            const key = CREATE_KEY_FN$k(payload.actionName, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$m(payload.actionName, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             if (!this.getAction.has(key)) {
                 return;
             }
@@ -12582,7 +12743,7 @@ const METHOD_NAME_VALIDATE$2 = "exchangeCoreService validate";
  * @param exchangeName - Exchange name
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$j = (exchangeName) => {
+const CREATE_KEY_FN$l = (exchangeName) => {
     return exchangeName;
 };
 /**
@@ -12606,7 +12767,7 @@ class ExchangeCoreService {
          * @param exchangeName - Name of the exchange to validate
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([exchangeName]) => CREATE_KEY_FN$j(exchangeName), async (exchangeName) => {
+        this.validate = memoize(([exchangeName]) => CREATE_KEY_FN$l(exchangeName), async (exchangeName) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$2, {
                 exchangeName,
             });
@@ -12858,7 +13019,7 @@ const METHOD_NAME_VALIDATE$1 = "strategyCoreService validate";
  * @param context - Execution context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$i = (context) => {
+const CREATE_KEY_FN$k = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -12890,7 +13051,7 @@ class StrategyCoreService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$i(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$k(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$1, {
                 context,
             });
@@ -13725,7 +13886,7 @@ class SizingGlobalService {
  * @param context - Context with riskName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$h = (context) => {
+const CREATE_KEY_FN$j = (context) => {
     const parts = [context.riskName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -13751,7 +13912,7 @@ class RiskGlobalService {
          * @param payload - Payload with riskName, exchangeName and frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$h(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$j(context), async (context) => {
             this.loggerService.log("riskGlobalService validate", {
                 context,
             });
@@ -13829,7 +13990,7 @@ const METHOD_NAME_VALIDATE = "actionCoreService validate";
  * @param context - Execution context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$g = (context) => {
+const CREATE_KEY_FN$i = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -13873,7 +14034,7 @@ class ActionCoreService {
          * @param context - Strategy execution context with strategyName, exchangeName and frameName
          * @returns Promise that resolves when all validations complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$g(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$i(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE, {
                 context,
             });
@@ -18408,7 +18569,7 @@ const Markdown = new MarkdownAdapter();
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$f = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$h = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -18647,7 +18808,7 @@ class BacktestMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$f(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$8(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$h(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$8(symbol, strategyName, exchangeName, frameName));
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -18804,7 +18965,7 @@ class BacktestMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$f(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$h(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -18866,7 +19027,7 @@ class BacktestMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$e = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$g = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -19349,7 +19510,7 @@ class LiveMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$e(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$7(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$g(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$7(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to live signal emitter to receive tick events.
          * Protected against multiple subscriptions.
@@ -19567,7 +19728,7 @@ class LiveMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$e(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$g(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -19587,7 +19748,7 @@ class LiveMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$d = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$f = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -19878,7 +20039,7 @@ class ScheduleMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$d(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$6(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$f(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$6(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to signal emitter to receive scheduled signal events.
          * Protected against multiple subscriptions.
@@ -20081,7 +20242,7 @@ class ScheduleMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$d(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$f(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -20101,7 +20262,7 @@ class ScheduleMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$c = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$e = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -20349,7 +20510,7 @@ class PerformanceMarkdownService {
          * Memoized function to get or create PerformanceStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$c(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new PerformanceStorage(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$e(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new PerformanceStorage(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to performance emitter to receive performance events.
          * Protected against multiple subscriptions.
@@ -20516,7 +20677,7 @@ class PerformanceMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$c(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$e(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -20986,7 +21147,7 @@ class WalkerMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$b = (exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$d = (exchangeName, frameName, backtest) => {
     const parts = [exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -21353,7 +21514,7 @@ class HeatMarkdownService {
          * Memoized function to get or create HeatmapStorage for exchange, frame and backtest mode.
          * Each exchangeName + frameName + backtest mode combination gets its own isolated heatmap storage instance.
          */
-        this.getStorage = memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$b(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
+        this.getStorage = memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$d(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
         /**
          * Subscribes to signal emitter to receive tick events.
          * Protected against multiple subscriptions.
@@ -21548,7 +21709,7 @@ class HeatMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$b(payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$d(payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -22579,7 +22740,7 @@ class ClientPartial {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$a = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$c = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
 /**
  * Creates a callback function for emitting profit events to partialProfitSubject.
  *
@@ -22701,7 +22862,7 @@ class PartialConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientPartial instance with logger and event emitters
          */
-        this.getPartial = memoize(([signalId, backtest]) => CREATE_KEY_FN$a(signalId, backtest), (signalId, backtest) => {
+        this.getPartial = memoize(([signalId, backtest]) => CREATE_KEY_FN$c(signalId, backtest), (signalId, backtest) => {
             return new ClientPartial({
                 signalId,
                 logger: this.loggerService,
@@ -22791,7 +22952,7 @@ class PartialConnectionService {
             const partial = this.getPartial(data.id, backtest);
             await partial.waitForInit(symbol, data.strategyName, data.exchangeName, backtest);
             await partial.clear(symbol, data, priceClose, backtest);
-            const key = CREATE_KEY_FN$a(data.id, backtest);
+            const key = CREATE_KEY_FN$c(data.id, backtest);
             this.getPartial.clear(key);
         };
     }
@@ -22807,7 +22968,7 @@ class PartialConnectionService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$9 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$b = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -23032,7 +23193,7 @@ class PartialMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$9(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$4(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$b(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$4(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to partial profit/loss signal emitters to receive events.
          * Protected against multiple subscriptions.
@@ -23242,7 +23403,7 @@ class PartialMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$9(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$b(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -23258,7 +23419,7 @@ class PartialMarkdownService {
  * @param context - Context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$8 = (context) => {
+const CREATE_KEY_FN$a = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -23332,7 +23493,7 @@ class PartialGlobalService {
          * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$8(context), (context, methodName) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$a(context), (context, methodName) => {
             this.loggerService.log("partialGlobalService validate", {
                 context,
                 methodName,
@@ -23787,7 +23948,7 @@ class ClientBreakeven {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$7 = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$9 = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
 /**
  * Creates a callback function for emitting breakeven events to breakevenSubject.
  *
@@ -23873,7 +24034,7 @@ class BreakevenConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientBreakeven instance with logger and event emitter
          */
-        this.getBreakeven = memoize(([signalId, backtest]) => CREATE_KEY_FN$7(signalId, backtest), (signalId, backtest) => {
+        this.getBreakeven = memoize(([signalId, backtest]) => CREATE_KEY_FN$9(signalId, backtest), (signalId, backtest) => {
             return new ClientBreakeven({
                 signalId,
                 logger: this.loggerService,
@@ -23934,7 +24095,7 @@ class BreakevenConnectionService {
             const breakeven = this.getBreakeven(data.id, backtest);
             await breakeven.waitForInit(symbol, data.strategyName, data.exchangeName, backtest);
             await breakeven.clear(symbol, data, priceClose, backtest);
-            const key = CREATE_KEY_FN$7(data.id, backtest);
+            const key = CREATE_KEY_FN$9(data.id, backtest);
             this.getBreakeven.clear(key);
         };
     }
@@ -23950,7 +24111,7 @@ class BreakevenConnectionService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$6 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$8 = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -24127,7 +24288,7 @@ class BreakevenMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$3(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$8(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$3(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to breakeven signal emitter to receive events.
          * Protected against multiple subscriptions.
@@ -24316,7 +24477,7 @@ class BreakevenMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$6(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$8(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -24332,7 +24493,7 @@ class BreakevenMarkdownService {
  * @param context - Context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$5 = (context) => {
+const CREATE_KEY_FN$7 = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -24406,7 +24567,7 @@ class BreakevenGlobalService {
          * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$5(context), (context, methodName) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$7(context), (context, methodName) => {
             this.loggerService.log("breakevenGlobalService validate", {
                 context,
                 methodName,
@@ -24626,7 +24787,7 @@ class ConfigValidationService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$4 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$6 = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -24795,7 +24956,7 @@ class RiskMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$4(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$2(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$2(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to risk rejection emitter to receive rejection events.
          * Protected against multiple subscriptions.
@@ -24984,7 +25145,7 @@ class RiskMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$4(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$6(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -27672,7 +27833,7 @@ class SyncReportService {
  * @returns Colon-separated key string for memoization
  * @internal
  */
-const CREATE_KEY_FN$3 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$5 = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -27920,7 +28081,7 @@ class StrategyMarkdownService {
          *
          * @internal
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$3(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$1(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$5(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$1(symbol, strategyName, exchangeName, frameName));
         /**
          * Records a cancel-scheduled event when a scheduled signal is cancelled.
          *
@@ -28488,7 +28649,7 @@ class StrategyMarkdownService {
         this.clear = async (payload) => {
             this.loggerService.log("strategyMarkdownService clear", { payload });
             if (payload) {
-                const key = CREATE_KEY_FN$3(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$5(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -28596,7 +28757,7 @@ class StrategyMarkdownService {
  * Creates a unique key for memoizing ReportStorage instances.
  * Key format: "symbol:strategyName:exchangeName[:frameName]:backtest|live"
  */
-const CREATE_KEY_FN$2 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$4 = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -28728,7 +28889,7 @@ class ReportStorage {
 class SyncMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$2(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$4(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage(symbol, strategyName, exchangeName, frameName));
         this.subscribe = singleshot(() => {
             this.loggerService.log("syncMarkdownService init");
             const unsubscribe = syncSubject.subscribe(this.tick);
@@ -28803,7 +28964,7 @@ class SyncMarkdownService {
         this.clear = async (payload) => {
             this.loggerService.log("syncMarkdownService clear", { payload });
             if (payload) {
-                const key = CREATE_KEY_FN$2(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$4(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -28813,6 +28974,275 @@ class SyncMarkdownService {
     }
 }
 
+const LISTEN_TIMEOUT$1 = 120000;
+/**
+ * Creates a unique memoization key for a price stream.
+ * Key format: "symbol:strategyName:exchangeName[:frameName]:backtest|live"
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param strategyName - Strategy identifier
+ * @param exchangeName - Exchange identifier
+ * @param frameName - Frame identifier (omitted when empty)
+ * @param backtest - Whether running in backtest mode
+ * @returns Unique string key for memoization
+ */
+const CREATE_KEY_FN$3 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
+/**
+ * Service for tracking the latest market price per symbol-strategy-exchange-frame combination.
+ *
+ * Maintains a memoized BehaviorSubject per unique key that is updated on every strategy tick
+ * by StrategyConnectionService. Consumers can synchronously read the last known price or
+ * await the first value if none has arrived yet.
+ *
+ * Primary use case: providing the current price outside of a tick execution context,
+ * e.g., when a command is triggered between ticks.
+ *
+ * Features:
+ * - One BehaviorSubject per (symbol, strategyName, exchangeName, frameName, backtest) key
+ * - Falls back to ExchangeConnectionService.getAveragePrice when called inside an execution context
+ * - Waits up to LISTEN_TIMEOUT ms for the first price if none is cached yet
+ * - clear() disposes the BehaviorSubject for a single key or all keys
+ *
+ * Architecture:
+ * - Registered as singleton in DI container
+ * - Updated by StrategyConnectionService after each tick
+ * - Cleared by Backtest/Live/Walker at strategy start to prevent stale data
+ *
+ * @example
+ * ```typescript
+ * const price = await backtest.priceMetaService.getCurrentPrice("BTCUSDT", context, false);
+ * ```
+ */
+class PriceMetaService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
+        /**
+         * Memoized factory for BehaviorSubject streams keyed by (symbol, strategyName, exchangeName, frameName, backtest).
+         *
+         * Each subject holds the latest currentPrice emitted by the strategy iterator for that key.
+         * Instances are cached until clear() is called.
+         */
+        this.getSource = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$3(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
+        /**
+         * Returns the current market price for the given symbol and context.
+         *
+         * When called inside an execution context (i.e., during a signal handler or action),
+         * delegates to ExchangeConnectionService.getAveragePrice for the live exchange price.
+         * Otherwise, reads the last value from the cached BehaviorSubject. If no value has
+         * been emitted yet, waits up to LISTEN_TIMEOUT ms for the first tick before throwing.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Strategy, exchange, and frame identifiers
+         * @param backtest - True if backtest mode, false if live mode
+         * @returns Current market price in quote currency
+         * @throws When no price arrives within LISTEN_TIMEOUT ms
+         */
+        this.getCurrentPrice = async (symbol, context, backtest) => {
+            this.loggerService.log("priceMetaService getCurrentPrice", {
+                symbol,
+                context,
+                backtest,
+            });
+            if (ExecutionContextService.hasContext() &&
+                MethodContextService.hasContext()) {
+                return await this.exchangeConnectionService.getAveragePrice(symbol);
+            }
+            const source = this.getSource(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            if (source.data) {
+                return source.data;
+            }
+            console.warn(`PriceMetaService: No currentPrice available for ${CREATE_KEY_FN$3(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}. Trying to fetch from strategy iterator as a fallback...`);
+            const currentPrice = await waitForNext(source, (data) => !!data, LISTEN_TIMEOUT$1);
+            if (typeof currentPrice === "symbol") {
+                throw new Error(`PriceMetaService: Timeout while waiting for currentPrice for ${CREATE_KEY_FN$3(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}`);
+            }
+            return currentPrice;
+        };
+        /**
+         * Pushes a new price value into the BehaviorSubject for the given key.
+         *
+         * Called by StrategyConnectionService after each strategy tick to keep
+         * the cached price up to date.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param currentPrice - The latest price from the tick
+         * @param context - Strategy, exchange, and frame identifiers
+         * @param backtest - True if backtest mode, false if live mode
+         */
+        this.next = async (symbol, currentPrice, context, backtest) => {
+            this.loggerService.log("priceMetaService next", {
+                symbol,
+                currentPrice,
+                context,
+                backtest,
+            });
+            const source = this.getSource(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            source.next(currentPrice);
+        };
+        /**
+         * Disposes cached BehaviorSubject(s) to free memory and prevent stale data.
+         *
+         * When called without arguments, clears all memoized price streams.
+         * When called with a payload, clears only the stream for the specified key.
+         * Should be called at strategy start (Backtest/Live/Walker) to reset state.
+         *
+         * @param payload - Optional key to clear a single stream; omit to clear all
+         */
+        this.clear = (payload) => {
+            this.loggerService.log("priceMetaService clear", {
+                payload
+            });
+            if (!payload) {
+                this.getSource.clear();
+                return;
+            }
+            const key = CREATE_KEY_FN$3(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            this.getSource.clear(key);
+        };
+    }
+}
+
+const LISTEN_TIMEOUT = 120000;
+/**
+ * Creates a unique memoization key for a timestamp stream.
+ * Key format: "symbol:strategyName:exchangeName[:frameName]:backtest|live"
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param strategyName - Strategy identifier
+ * @param exchangeName - Exchange identifier
+ * @param frameName - Frame identifier (omitted when empty)
+ * @param backtest - Whether running in backtest mode
+ * @returns Unique string key for memoization
+ */
+const CREATE_KEY_FN$2 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
+/**
+ * Service for tracking the latest candle timestamp per symbol-strategy-exchange-frame combination.
+ *
+ * Maintains a memoized BehaviorSubject per unique key that is updated on every strategy tick
+ * by StrategyConnectionService. Consumers can synchronously read the last known timestamp or
+ * await the first value if none has arrived yet.
+ *
+ * Primary use case: providing the current candle time outside of a tick execution context,
+ * e.g., when a command is triggered between ticks.
+ *
+ * Features:
+ * - One BehaviorSubject per (symbol, strategyName, exchangeName, frameName, backtest) key
+ * - Falls back to ExecutionContextService.context.when when called inside an execution context
+ * - Waits up to LISTEN_TIMEOUT ms for the first timestamp if none is cached yet
+ * - clear() disposes the BehaviorSubject for a single key or all keys
+ *
+ * Architecture:
+ * - Registered as singleton in DI container
+ * - Updated by StrategyConnectionService after each tick
+ * - Cleared by Backtest/Live/Walker at strategy start to prevent stale data
+ *
+ * @example
+ * ```typescript
+ * const ts = await backtest.timeMetaService.getTimestamp("BTCUSDT", context, false);
+ * ```
+ */
+class TimeMetaService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.executionContextService = inject(TYPES.executionContextService);
+        /**
+         * Memoized factory for BehaviorSubject streams keyed by (symbol, strategyName, exchangeName, frameName, backtest).
+         *
+         * Each subject holds the latest createdAt timestamp emitted by the strategy iterator for that key.
+         * Instances are cached until clear() is called.
+         */
+        this.getSource = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$2(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
+        /**
+         * Returns the current candle timestamp (in milliseconds) for the given symbol and context.
+         *
+         * When called inside an execution context (i.e., during a signal handler or action),
+         * reads the timestamp directly from ExecutionContextService.context.when.
+         * Otherwise, reads the last value from the cached BehaviorSubject. If no value has
+         * been emitted yet, waits up to LISTEN_TIMEOUT ms for the first tick before throwing.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Strategy, exchange, and frame identifiers
+         * @param backtest - True if backtest mode, false if live mode
+         * @returns Unix timestamp in milliseconds of the latest processed candle
+         * @throws When no timestamp arrives within LISTEN_TIMEOUT ms
+         */
+        this.getTimestamp = async (symbol, context, backtest) => {
+            this.loggerService.log("timeMetaService getTimestamp", {
+                symbol,
+                context,
+                backtest,
+            });
+            if (ExecutionContextService.hasContext()) {
+                return this.executionContextService.context.when.getTime();
+            }
+            const source = this.getSource(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            if (source.data) {
+                return source.data;
+            }
+            console.warn(`TimeMetaService: No timestamp available for ${CREATE_KEY_FN$2(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}. Trying to fetch from strategy iterator as a fallback...`);
+            const timestamp = await waitForNext(source, (data) => !!data, LISTEN_TIMEOUT);
+            if (typeof timestamp === "symbol") {
+                throw new Error(`TimeMetaService: Timeout while waiting for timestamp for ${CREATE_KEY_FN$2(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}`);
+            }
+            return timestamp;
+        };
+        /**
+         * Pushes a new timestamp value into the BehaviorSubject for the given key.
+         *
+         * Called by StrategyConnectionService after each strategy tick to keep
+         * the cached timestamp up to date.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param timestamp - The createdAt timestamp from the tick (milliseconds)
+         * @param context - Strategy, exchange, and frame identifiers
+         * @param backtest - True if backtest mode, false if live mode
+         */
+        this.next = async (symbol, timestamp, context, backtest) => {
+            this.loggerService.log("timeMetaService next", {
+                symbol,
+                timestamp,
+                context,
+                backtest,
+            });
+            const source = this.getSource(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            source.next(timestamp);
+        };
+        /**
+         * Disposes cached BehaviorSubject(s) to free memory and prevent stale data.
+         *
+         * When called without arguments, clears all memoized timestamp streams.
+         * When called with a payload, clears only the stream for the specified key.
+         * Should be called at strategy start (Backtest/Live/Walker) to reset state.
+         *
+         * @param payload - Optional key to clear a single stream; omit to clear all
+         */
+        this.clear = (payload) => {
+            this.loggerService.log("timeMetaService clear", {
+                payload,
+            });
+            if (!payload) {
+                this.getSource.clear();
+                return;
+            }
+            const key = CREATE_KEY_FN$2(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            this.getSource.clear(key);
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -28845,6 +29275,10 @@ class SyncMarkdownService {
     provide(TYPES.actionCoreService, () => new ActionCoreService());
     provide(TYPES.frameCoreService, () => new FrameCoreService());
 }
+{
+    provide(TYPES.priceMetaService, () => new PriceMetaService());
+    provide(TYPES.timeMetaService, () => new TimeMetaService());
+}
 {
     provide(TYPES.sizingGlobalService, () => new SizingGlobalService());
     provide(TYPES.riskGlobalService, () => new RiskGlobalService());
@@ -28936,6 +29370,10 @@ const coreServices = {
     actionCoreService: inject(TYPES.actionCoreService),
     frameCoreService: inject(TYPES.frameCoreService),
 };
+const metaServices = {
+    timeMetaService: inject(TYPES.timeMetaService),
+    priceMetaService: inject(TYPES.priceMetaService),
+};
 const globalServices = {
     sizingGlobalService: inject(TYPES.sizingGlobalService),
     riskGlobalService: inject(TYPES.riskGlobalService),
@@ -29000,6 +29438,7 @@ const backtest = {
     ...connectionServices,
     ...schemaServices,
     ...coreServices,
+    ...metaServices,
     ...globalServices,
     ...commandServices,
     ...logicPrivateServices,
@@ -34486,6 +34925,20 @@ class BacktestInstance {
                     frameName: context.frameName,
                     backtest: true,
                 });
+                bt.timeMetaService.clear({
+                    symbol,
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    backtest: true,
+                });
+                bt.priceMetaService.clear({
+                    symbol,
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    backtest: true,
+                });
             }
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
@@ -36390,6 +36843,20 @@ class LiveInstance {
                     frameName: "",
                     backtest: false,
                 });
+                bt.timeMetaService.clear({
+                    symbol,
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                    backtest: false,
+                });
+                bt.priceMetaService.clear({
+                    symbol,
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                    backtest: false,
+                });
             }
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
@@ -40538,6 +41005,20 @@ class WalkerInstance {
                         frameName: walkerSchema.frameName,
                         backtest: true,
                     });
+                    bt.timeMetaService.clear({
+                        symbol,
+                        strategyName,
+                        exchangeName: walkerSchema.exchangeName,
+                        frameName: walkerSchema.frameName,
+                        backtest: true,
+                    });
+                    bt.priceMetaService.clear({
+                        symbol,
+                        strategyName,
+                        exchangeName: walkerSchema.exchangeName,
+                        frameName: walkerSchema.frameName,
+                        backtest: true,
+                    });
                 }
                 {
                     const { riskName, riskList, actions } = bt.strategySchemaService.get(strategyName);
@@ -43505,13 +43986,15 @@ class NotificationMemoryBacktestUtils {
          * Handles signal sync events (signal-open, signal-close).
          * @param data - The signal sync contract data
          */
-        this.handleSync = async (data) => {
+        this.handleSync = trycatch(async (data) => {
             bt.loggerService.info(NOTIFICATION_MEMORY_BACKTEST_METHOD_NAME_HANDLE_SYNC, {
                 signalId: data.signalId,
                 action: data.action,
             });
             this._addNotification(CREATE_SIGNAL_SYNC_NOTIFICATION_FN(data));
-        };
+        }, {
+            defaultValue: null,
+        });
         /**
          * Handles risk rejection event.
          * @param data - The risk contract data
@@ -43620,8 +44103,10 @@ class NotificationDummyBacktestUtils {
         /**
          * No-op handler for signal sync event.
          */
-        this.handleSync = async () => {
-        };
+        this.handleSync = trycatch(async () => {
+        }, {
+            defaultValue: null,
+        });
         /**
          * No-op handler for risk rejection event.
          */
@@ -43760,7 +44245,7 @@ class NotificationPersistBacktestUtils {
          * Handles signal sync events (signal-open, signal-close).
          * @param data - The signal sync contract data
          */
-        this.handleSync = async (data) => {
+        this.handleSync = trycatch(async (data) => {
             bt.loggerService.info(NOTIFICATION_PERSIST_BACKTEST_METHOD_NAME_HANDLE_SYNC, {
                 signalId: data.signalId,
                 action: data.action,
@@ -43768,7 +44253,9 @@ class NotificationPersistBacktestUtils {
             await this.waitForInit();
             this._addNotification(CREATE_SIGNAL_SYNC_NOTIFICATION_FN(data));
             await this._updateNotifications();
-        };
+        }, {
+            defaultValue: null,
+        });
         /**
          * Handles risk rejection event.
          * @param data - The risk contract data
@@ -43951,13 +44438,15 @@ class NotificationMemoryLiveUtils {
          * Handles signal sync events (signal-open, signal-close).
          * @param data - The signal sync contract data
          */
-        this.handleSync = async (data) => {
+        this.handleSync = trycatch(async (data) => {
             bt.loggerService.info(NOTIFICATION_MEMORY_LIVE_METHOD_NAME_HANDLE_SYNC, {
                 signalId: data.signalId,
                 action: data.action,
             });
             this._addNotification(CREATE_SIGNAL_SYNC_NOTIFICATION_FN(data));
-        };
+        }, {
+            defaultValue: null,
+        });
         /**
          * Handles risk rejection event.
          * @param data - The risk contract data
@@ -44066,8 +44555,10 @@ class NotificationDummyLiveUtils {
         /**
          * No-op handler for signal sync event.
          */
-        this.handleSync = async () => {
-        };
+        this.handleSync = trycatch(async () => {
+        }, {
+            defaultValue: null,
+        });
         /**
          * No-op handler for risk rejection event.
          */
@@ -44207,7 +44698,7 @@ class NotificationPersistLiveUtils {
          * Handles signal sync events (signal-open, signal-close).
          * @param data - The signal sync contract data
          */
-        this.handleSync = async (data) => {
+        this.handleSync = trycatch(async (data) => {
             bt.loggerService.info(NOTIFICATION_PERSIST_LIVE_METHOD_NAME_HANDLE_SYNC, {
                 signalId: data.signalId,
                 action: data.action,
@@ -44215,7 +44706,9 @@ class NotificationPersistLiveUtils {
             await this.waitForInit();
             this._addNotification(CREATE_SIGNAL_SYNC_NOTIFICATION_FN(data));
             await this._updateNotifications();
-        };
+        }, {
+            defaultValue: null,
+        });
         /**
          * Handles risk rejection event.
          * @param data - The risk contract data
@@ -44377,9 +44870,11 @@ class NotificationBacktestAdapter {
          * Proxies call to the underlying notification adapter.
          * @param data - The signal sync contract data
          */
-        this.handleSync = async (data) => {
+        this.handleSync = trycatch(async (data) => {
             return await this._notificationBacktestUtils.handleSync(data);
-        };
+        }, {
+            defaultValue: null,
+        });
         /**
          * Handles risk rejection event.
          * Proxies call to the underlying notification adapter.
@@ -44521,9 +45016,11 @@ class NotificationLiveAdapter {
          * Proxies call to the underlying notification adapter.
          * @param data - The signal sync contract data
          */
-        this.handleSync = async (data) => {
+        this.handleSync = trycatch(async (data) => {
             return await this._notificationLiveUtils.handleSync(data);
-        };
+        }, {
+            defaultValue: null,
+        });
         /**
          * Handles risk rejection event.
          * Proxies call to the underlying notification adapter.