backtest-kit 1.13.4 → 2.0.1

package/build/index.mjs

@@ -1,6 +1,6 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { Subject, trycatch, errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, retry, randomString, isObject, ToolRegistry, and, resolveDocuments, str, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, iterateDocuments, distinctDocuments, queued, singlerun } from 'functools-kit';
+import { Subject, trycatch, errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, retry, randomString, str, isObject, ToolRegistry, and, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, iterateDocuments, distinctDocuments, queued, singlerun } from 'functools-kit';
 import * as fs from 'fs/promises';
 import fs__default, { mkdir, writeFile } from 'fs/promises';
 import path, { join, dirname } from 'path';
@@ -521,14 +521,21 @@ const breakevenSubject = new Subject();
  */
 const riskSubject = new Subject();
 /**
- * Ping emitter for scheduled signal monitoring events.
+ * Schedule ping emitter for scheduled signal monitoring events.
  * Emits every minute when a scheduled signal is being monitored (waiting for activation).
  * Allows users to track scheduled signal lifecycle and implement custom cancellation logic.
  */
-const pingSubject = new Subject();
+const schedulePingSubject = new Subject();
+/**
+ * Active ping emitter for active pending signal monitoring events.
+ * Emits every minute when an active pending signal is being monitored.
+ * Allows users to track active signal lifecycle and implement custom dynamic management logic.
+ */
+const activePingSubject = new Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    activePingSubject: activePingSubject,
     breakevenSubject: breakevenSubject,
     doneBacktestSubject: doneBacktestSubject,
     doneLiveSubject: doneLiveSubject,
@@ -538,11 +545,11 @@ var emitters = /*#__PURE__*/Object.freeze({
     partialLossSubject: partialLossSubject,
     partialProfitSubject: partialProfitSubject,
     performanceEmitter: performanceEmitter,
-    pingSubject: pingSubject,
     progressBacktestEmitter: progressBacktestEmitter,
     progressOptimizerEmitter: progressOptimizerEmitter,
     progressWalkerEmitter: progressWalkerEmitter,
     riskSubject: riskSubject,
+    schedulePingSubject: schedulePingSubject,
     signalBacktestEmitter: signalBacktestEmitter,
     signalEmitter: signalEmitter,
     signalLiveEmitter: signalLiveEmitter,
@@ -753,11 +760,16 @@ class ClientExchange {
         const whenTimestamp = this.params.execution.context.when.getTime();
         const sinceTimestamp = since.getTime();
         const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp <= whenTimestamp);
-        if (filteredData.length < limit) {
-            this.params.logger.warn(`ClientExchange Expected ${limit} candles, got ${filteredData.length}`);
+        // Apply distinct by timestamp to remove duplicates
+        const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
+        if (filteredData.length !== uniqueData.length) {
+            this.params.logger.warn(`ClientExchange Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`);
         }
-        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, filteredData);
-        return filteredData;
+        if (uniqueData.length < limit) {
+            this.params.logger.warn(`ClientExchange Expected ${limit} candles, got ${uniqueData.length}`);
+        }
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, uniqueData);
+        return uniqueData;
     }
     /**
      * Fetches future candles forwards from execution context time.
@@ -806,11 +818,16 @@ class ClientExchange {
         // Filter candles to strictly match the requested range
         const sinceTimestamp = since.getTime();
         const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp <= endTime);
-        if (filteredData.length < limit) {
-            this.params.logger.warn(`ClientExchange getNextCandles: Expected ${limit} candles, got ${filteredData.length}`);
+        // Apply distinct by timestamp to remove duplicates
+        const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
+        if (filteredData.length !== uniqueData.length) {
+            this.params.logger.warn(`ClientExchange getNextCandles: Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`);
+        }
+        if (uniqueData.length < limit) {
+            this.params.logger.warn(`ClientExchange getNextCandles: Expected ${limit} candles, got ${uniqueData.length}`);
         }
-        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, filteredData);
-        return filteredData;
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, uniqueData);
+        return uniqueData;
     }
     /**
      * Calculates VWAP (Volume Weighted Average Price) from last N 1m candles.
@@ -3386,14 +3403,14 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
     await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, activationTime, self.params.execution.context.backtest);
     return result;
 };
-const CALL_PING_CALLBACKS_FN = trycatch(beginTime(async (self, symbol, scheduled, timestamp, backtest) => {
+const CALL_SCHEDULE_PING_CALLBACKS_FN = trycatch(beginTime(async (self, symbol, scheduled, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
         const publicSignal = TO_PUBLIC_SIGNAL(scheduled);
-        // Call system onPing callback first (emits to pingSubject)
-        await self.params.onPing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, publicSignal, self.params.execution.context.backtest, timestamp);
-        // Call user onPing callback only if signal is still active (not cancelled, not activated)
-        if (self.params.callbacks?.onPing) {
-            await self.params.callbacks.onPing(self.params.execution.context.symbol, publicSignal, new Date(timestamp), self.params.execution.context.backtest);
+        // 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);
+        // 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);
         }
     }, {
         when: new Date(timestamp),
@@ -3402,7 +3419,33 @@ const CALL_PING_CALLBACKS_FN = trycatch(beginTime(async (self, symbol, scheduled
     });
 }), {
     fallback: (error) => {
-        const message = "ClientStrategy CALL_PING_CALLBACKS_FN thrown";
+        const message = "ClientStrategy CALL_SCHEDULE_PING_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_ACTIVE_PING_CALLBACKS_FN = trycatch(beginTime(async (self, symbol, pending, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        const publicSignal = TO_PUBLIC_SIGNAL(pending);
+        // 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);
+        // 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);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}), {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_ACTIVE_PING_CALLBACKS_FN thrown";
         const payload = {
             error: errorData(error),
             message: getErrorMessage(error),
@@ -3774,10 +3817,10 @@ const CALL_BREAKEVEN_CLEAR_FN = trycatch(beginTime(async (self, symbol, signal,
 });
 const RETURN_SCHEDULED_SIGNAL_ACTIVE_FN = async (self, scheduled, currentPrice) => {
     const currentTime = self.params.execution.context.when.getTime();
-    await CALL_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, currentTime, self.params.execution.context.backtest);
+    await CALL_SCHEDULE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, currentTime, self.params.execution.context.backtest);
     const pnl = toProfitLossDto(scheduled, currentPrice);
     const result = {
-        action: "active",
+        action: "waiting",
         signal: TO_PUBLIC_SIGNAL(scheduled),
         currentPrice: currentPrice,
         strategyName: self.params.method.context.strategyName,
@@ -3904,6 +3947,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
     let percentTp = 0;
     let percentSl = 0;
     const currentTime = self.params.execution.context.when.getTime();
+    await CALL_ACTIVE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentTime, self.params.execution.context.backtest);
     // Calculate percentage of path to TP/SL for partial fill/loss callbacks
     {
         if (signal.position === "long") {
@@ -4109,7 +4153,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
         const averagePrice = GET_AVG_PRICE_FN(recentCandles);
         // КРИТИЧНО: Проверяем был ли сигнал отменен пользователем через cancel()
         if (self._cancelledSignal) {
-            // Сигнал был отменен через cancel() в onPing
+            // Сигнал был отменен через 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 };
         }
@@ -4166,7 +4210,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                 result: null,
             };
         }
-        await CALL_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, candle.timestamp, true);
+        await CALL_SCHEDULE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, candle.timestamp, true);
     }
     return {
         activated: false,
@@ -4192,6 +4236,7 @@ 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);
+        await CALL_ACTIVE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentCandleTimestamp, true);
         let shouldClose = false;
         let closeReason;
         // Check time expiration FIRST (КРИТИЧНО!)
@@ -4737,7 +4782,15 @@ class ClientStrategy {
                 return result;
             }
             if (activated) {
-                const remainingCandles = candles.slice(activationIndex + 1);
+                // КРИТИЧНО: activationIndex - индекс свечи активации в массиве candles
+                // BacktestLogicPrivateService включил буфер в начало массива, поэтому перед activationIndex достаточно свечей
+                // PROCESS_PENDING_SIGNAL_CANDLES_FN пропустит первые bufferCandlesCount свечей для VWAP
+                // Чтобы обработка началась со СЛЕДУЮЩЕЙ свечи после активации (activationIndex + 1),
+                // нужно взять срез начиная с (activationIndex + 1 - bufferCandlesCount)
+                // Это даст буфер ИЗ scheduled фазы + свеча после активации как первая обрабатываемая
+                const bufferCandlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
+                const sliceStart = Math.max(0, activationIndex + 1 - bufferCandlesCount);
+                const remainingCandles = candles.slice(sliceStart);
                 if (remainingCandles.length === 0) {
                     const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
                     const recentCandles = candles.slice(Math.max(0, activationIndex - (candlesCount - 1)), activationIndex + 1);
@@ -4753,35 +4806,23 @@ class ClientStrategy {
                 const lastCandleTimestamp = candles[candles.length - 1].timestamp;
                 const elapsedTime = lastCandleTimestamp - scheduled.scheduledAt;
                 if (elapsedTime < maxTimeToWait) {
-                    // Timeout NOT reached yet - signal is still active (waiting for price)
-                    // Return active result to continue monitoring in next backtest() call
-                    const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
-                    const lastCandles = candles.slice(-candlesCount);
-                    const lastPrice = GET_AVG_PRICE_FN(lastCandles);
-                    this.params.logger.debug("ClientStrategy backtest scheduled signal still waiting (not expired)", {
-                        symbol: this.params.execution.context.symbol,
-                        signalId: scheduled.id,
-                        elapsedMinutes: Math.floor(elapsedTime / 60000),
-                        maxMinutes: GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES,
-                    });
-                    // Don't cancel - just return last active state
-                    // In real backtest flow this won't happen as we process all candles at once,
-                    // but this is correct behavior if someone calls backtest() with partial data
-                    const pnl = toProfitLossDto(scheduled, lastPrice);
-                    const result = {
-                        action: "active",
-                        signal: TO_PUBLIC_SIGNAL(scheduled),
-                        currentPrice: lastPrice,
-                        percentSl: 0,
-                        percentTp: 0,
-                        pnl,
-                        strategyName: this.params.method.context.strategyName,
-                        exchangeName: this.params.method.context.exchangeName,
-                        frameName: this.params.method.context.frameName,
-                        symbol: this.params.execution.context.symbol,
-                        backtest: this.params.execution.context.backtest,
-                    };
-                    return result; // Cast to IStrategyBacktestResult (which includes Active)
+                    // EDGE CASE: backtest() called with partial candle data (should never happen in production)
+                    // In real backtest flow this won't happen as we process all candles at once
+                    // This indicates incorrect usage of backtest() - throw error instead of returning partial result
+                    const bufferCandlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
+                    // For scheduled signal that has NOT activated: buffer + wait time only (no lifetime yet)
+                    const requiredCandlesCount = bufferCandlesCount + GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES + 1;
+                    throw new Error(str.newline(`ClientStrategy backtest: Insufficient candle data for scheduled signal (not yet activated). ` +
+                        `Signal scheduled at ${new Date(scheduled.scheduledAt).toISOString()}, ` +
+                        `last candle at ${new Date(lastCandleTimestamp).toISOString()}. ` +
+                        `Elapsed: ${Math.floor(elapsedTime / 60000)}min of ${GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES}min wait time. ` +
+                        `Provided ${candles.length} candles, but need at least ${requiredCandlesCount} candles. ` +
+                        `\nBreakdown: ` +
+                        `${bufferCandlesCount} buffer (VWAP) + ` +
+                        `${GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES} wait (for activation) = ${requiredCandlesCount} total. ` +
+                        `\nBuffer explanation: VWAP calculation requires ${GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT} candles, ` +
+                        `so first ${bufferCandlesCount} candles are skipped during scheduled phase processing. ` +
+                        `Provide complete candle range: [scheduledAt - ${bufferCandlesCount}min, scheduledAt + ${GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES}min].`));
                 }
                 // Timeout reached - cancel the scheduled signal
                 const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
@@ -4811,9 +4852,29 @@ class ClientStrategy {
         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
         return await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(this, signal, lastPrice, "time_expired", closeTimestamp);
     }
     /**
@@ -5602,6 +5663,9 @@ class ClientStrategy {
 const RISK_METHOD_NAME_GET_DATA = "RiskUtils.getData";
 const RISK_METHOD_NAME_GET_REPORT = "RiskUtils.getReport";
 const RISK_METHOD_NAME_DUMP = "RiskUtils.dump";
+const RISK_METHOD_NAME_CHECK_SIGNAL = "MergeRisk.checkSignal";
+const RISK_METHOD_NAME_ADD_SIGNAL = "MergeRisk.addSignal";
+const RISK_METHOD_NAME_REMOVE_SIGNAL = "MergeRisk.removeSignal";
 /**
  * Composite risk management class that combines multiple risk profiles.
  *
@@ -5657,7 +5721,7 @@ class MergeRisk {
      * @returns Promise resolving to true if all risks approve, false if any risk rejects
      */
     async checkSignal(params) {
-        backtest$1.loggerService.info("MergeRisk checkSignal", {
+        backtest$1.loggerService.info(RISK_METHOD_NAME_CHECK_SIGNAL, {
             params,
         });
         for (const [riskName, risk] of Object.entries(this._riskMap)) {
@@ -5681,7 +5745,7 @@ class MergeRisk {
      * @returns Promise that resolves when all risks have registered the signal
      */
     async addSignal(symbol, context, positionData) {
-        backtest$1.loggerService.info("MergeRisk addSignal", {
+        backtest$1.loggerService.info(RISK_METHOD_NAME_ADD_SIGNAL, {
             symbol,
             context,
         });
@@ -5698,7 +5762,7 @@ class MergeRisk {
      * @returns Promise that resolves when all risks have removed the signal
      */
     async removeSignal(symbol, context) {
-        backtest$1.loggerService.info("MergeRisk removeSignal", {
+        backtest$1.loggerService.info(RISK_METHOD_NAME_REMOVE_SIGNAL, {
             symbol,
             context,
         });
@@ -5981,15 +6045,15 @@ const CREATE_KEY_FN$k = (symbol, strategyName, exchangeName, frameName, backtest
     return parts.join(":");
 };
 /**
- * Creates a callback function for emitting ping events to pingSubject.
+ * Creates a callback function for emitting schedule ping events to pingSubject.
  *
  * Called by ClientStrategy when a scheduled signal is being monitored every minute.
  * Emits PingContract event to all subscribers and calls ActionCoreService.
  *
  * @param self - Reference to StrategyConnectionService instance
- * @returns Callback function for ping events
+ * @returns Callback function for schedule ping events
  */
-const CREATE_COMMIT_PING_FN = (self) => async (symbol, strategyName, exchangeName, data, backtest, timestamp) => {
+const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => async (symbol, strategyName, exchangeName, data, backtest, timestamp) => {
     const event = {
         symbol,
         strategyName,
@@ -5998,8 +6062,29 @@ const CREATE_COMMIT_PING_FN = (self) => async (symbol, strategyName, exchangeNam
         backtest,
         timestamp,
     };
-    await pingSubject.next(event);
-    await self.actionCoreService.ping(backtest, event, { strategyName, exchangeName, frameName: data.frameName });
+    await schedulePingSubject.next(event);
+    await self.actionCoreService.pingScheduled(backtest, event, { strategyName, exchangeName, frameName: data.frameName });
+};
+/**
+ * Creates a callback function for emitting active ping events.
+ *
+ * Called by ClientStrategy when an active pending signal is being monitored every minute.
+ * Placeholder for future activePingSubject implementation.
+ *
+ * @param self - Reference to StrategyConnectionService instance
+ * @returns Callback function for active ping events
+ */
+const CREATE_COMMIT_ACTIVE_PING_FN = (self) => async (symbol, strategyName, exchangeName, data, backtest, timestamp) => {
+    const event = {
+        symbol,
+        strategyName,
+        exchangeName,
+        data,
+        backtest,
+        timestamp,
+    };
+    await activePingSubject.next(event);
+    await self.actionCoreService.pingActive(backtest, event, { strategyName, exchangeName, frameName: data.frameName });
 };
 /**
  * Creates a callback function for emitting init events.
@@ -6096,7 +6181,8 @@ class StrategyConnectionService {
                 getSignal,
                 callbacks,
                 onInit: CREATE_COMMIT_INIT_FN(this),
-                onPing: CREATE_COMMIT_PING_FN(this),
+                onSchedulePing: CREATE_COMMIT_SCHEDULE_PING_FN(this),
+                onActivePing: CREATE_COMMIT_ACTIVE_PING_FN(this),
                 onDispose: CREATE_COMMIT_DISPOSE_FN(this),
             });
         });
@@ -7489,8 +7575,8 @@ const CALL_SIGNAL_BACKTEST_CALLBACK_FN = trycatch(async (self, event, strategyNa
 });
 /** Wrapper to call breakeven callback with error handling */
 const CALL_BREAKEVEN_CALLBACK_FN = trycatch(async (self, event, strategyName, frameName, backtest) => {
-    if (self.params.callbacks?.onBreakeven) {
-        await self.params.callbacks.onBreakeven(event, self.params.actionName, strategyName, frameName, backtest);
+    if (self.params.callbacks?.onBreakevenAvailable) {
+        await self.params.callbacks.onBreakevenAvailable(event, self.params.actionName, strategyName, frameName, backtest);
     }
 }, {
     fallback: (error) => {
@@ -7506,8 +7592,8 @@ const CALL_BREAKEVEN_CALLBACK_FN = trycatch(async (self, event, strategyName, fr
 });
 /** Wrapper to call partialProfit callback with error handling */
 const CALL_PARTIAL_PROFIT_CALLBACK_FN = trycatch(async (self, event, strategyName, frameName, backtest) => {
-    if (self.params.callbacks?.onPartialProfit) {
-        await self.params.callbacks.onPartialProfit(event, self.params.actionName, strategyName, frameName, backtest);
+    if (self.params.callbacks?.onPartialProfitAvailable) {
+        await self.params.callbacks.onPartialProfitAvailable(event, self.params.actionName, strategyName, frameName, backtest);
     }
 }, {
     fallback: (error) => {
@@ -7523,8 +7609,8 @@ const CALL_PARTIAL_PROFIT_CALLBACK_FN = trycatch(async (self, event, strategyNam
 });
 /** Wrapper to call partialLoss callback with error handling */
 const CALL_PARTIAL_LOSS_CALLBACK_FN = trycatch(async (self, event, strategyName, frameName, backtest) => {
-    if (self.params.callbacks?.onPartialLoss) {
-        await self.params.callbacks.onPartialLoss(event, self.params.actionName, strategyName, frameName, backtest);
+    if (self.params.callbacks?.onPartialLossAvailable) {
+        await self.params.callbacks.onPartialLossAvailable(event, self.params.actionName, strategyName, frameName, backtest);
     }
 }, {
     fallback: (error) => {
@@ -7538,14 +7624,31 @@ const CALL_PARTIAL_LOSS_CALLBACK_FN = trycatch(async (self, event, strategyName,
         errorEmitter.next(error);
     },
 });
-/** Wrapper to call ping callback with error handling */
-const CALL_PING_CALLBACK_FN = trycatch(async (self, event, strategyName, frameName, backtest) => {
-    if (self.params.callbacks?.onPing) {
-        await self.params.callbacks.onPing(event, self.params.actionName, strategyName, frameName, backtest);
+/** Wrapper to call scheduled ping callback with error handling */
+const CALL_PING_SCHEDULED_CALLBACK_FN = trycatch(async (self, event, strategyName, frameName, backtest) => {
+    if (self.params.callbacks?.onPingScheduled) {
+        await self.params.callbacks.onPingScheduled(event, self.params.actionName, strategyName, frameName, backtest);
     }
 }, {
     fallback: (error) => {
-        const message = "ClientAction CALL_PING_CALLBACK_FN thrown";
+        const message = "ClientAction CALL_PING_SCHEDULED_CALLBACK_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/** Wrapper to call active ping callback with error handling */
+const CALL_PING_ACTIVE_CALLBACK_FN = trycatch(async (self, event, strategyName, frameName, backtest) => {
+    if (self.params.callbacks?.onPingActive) {
+        await self.params.callbacks.onPingActive(event, self.params.actionName, strategyName, frameName, backtest);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientAction CALL_PING_ACTIVE_CALLBACK_FN thrown";
         const payload = {
             error: errorData(error),
             message: getErrorMessage(error),
@@ -7620,6 +7723,7 @@ const CREATE_HANDLER_FN = (self) => {
             self.params.strategyName,
             self.params.frameName,
             self.params.actionName,
+            self.params.backtest,
         ]);
     }
     return self.params.handler;
@@ -7811,8 +7915,8 @@ class ClientAction {
     /**
      * Handles breakeven events when stop-loss is moved to entry price.
      */
-    async breakeven(event) {
-        this.params.logger.debug("ClientAction breakeven", {
+    async breakevenAvailable(event) {
+        this.params.logger.debug("ClientAction breakevenAvailable", {
             actionName: this.params.actionName,
             strategyName: this.params.strategyName,
             frameName: this.params.frameName,
@@ -7821,8 +7925,8 @@ class ClientAction {
             await this.waitForInit();
         }
         // Call handler method if defined
-        if (this._handlerInstance?.breakeven) {
-            await this._handlerInstance.breakeven(event);
+        if (this._handlerInstance?.breakevenAvailable) {
+            await this._handlerInstance.breakevenAvailable(event);
         }
         // Call callback if defined
         await CALL_BREAKEVEN_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
@@ -7831,8 +7935,8 @@ class ClientAction {
     /**
      * Handles partial profit level events (10%, 20%, 30%, etc).
      */
-    async partialProfit(event) {
-        this.params.logger.debug("ClientAction partialProfit", {
+    async partialProfitAvailable(event) {
+        this.params.logger.debug("ClientAction partialProfitAvailable", {
             actionName: this.params.actionName,
             strategyName: this.params.strategyName,
             frameName: this.params.frameName,
@@ -7841,8 +7945,8 @@ class ClientAction {
             await this.waitForInit();
         }
         // Call handler method if defined
-        if (this._handlerInstance?.partialProfit) {
-            await this._handlerInstance.partialProfit(event);
+        if (this._handlerInstance?.partialProfitAvailable) {
+            await this._handlerInstance.partialProfitAvailable(event);
         }
         // Call callback if defined
         await CALL_PARTIAL_PROFIT_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
@@ -7851,8 +7955,8 @@ class ClientAction {
     /**
      * Handles partial loss level events (-10%, -20%, -30%, etc).
      */
-    async partialLoss(event) {
-        this.params.logger.debug("ClientAction partialLoss", {
+    async partialLossAvailable(event) {
+        this.params.logger.debug("ClientAction partialLossAvailable", {
             actionName: this.params.actionName,
             strategyName: this.params.strategyName,
             frameName: this.params.frameName,
@@ -7861,18 +7965,18 @@ class ClientAction {
             await this.waitForInit();
         }
         // Call handler method if defined
-        if (this._handlerInstance?.partialLoss) {
-            await this._handlerInstance.partialLoss(event);
+        if (this._handlerInstance?.partialLossAvailable) {
+            await this._handlerInstance.partialLossAvailable(event);
         }
         // Call callback if defined
         await CALL_PARTIAL_LOSS_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
     }
     ;
     /**
-     * Handles ping events during scheduled signal monitoring.
+     * Handles scheduled ping events during scheduled signal monitoring.
      */
-    async ping(event) {
-        this.params.logger.debug("ClientAction ping", {
+    async pingScheduled(event) {
+        this.params.logger.debug("ClientAction pingScheduled", {
             actionName: this.params.actionName,
             strategyName: this.params.strategyName,
             frameName: this.params.frameName,
@@ -7881,11 +7985,31 @@ class ClientAction {
             await this.waitForInit();
         }
         // Call handler method if defined
-        if (this._handlerInstance?.ping) {
-            await this._handlerInstance.ping(event);
+        if (this._handlerInstance?.pingScheduled) {
+            await this._handlerInstance.pingScheduled(event);
         }
         // Call callback if defined
-        await CALL_PING_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
+        await CALL_PING_SCHEDULED_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
+    }
+    ;
+    /**
+     * Handles active ping events during active pending signal monitoring.
+     */
+    async pingActive(event) {
+        this.params.logger.debug("ClientAction pingActive", {
+            actionName: this.params.actionName,
+            strategyName: this.params.strategyName,
+            frameName: this.params.frameName,
+        });
+        if (!this._handlerInstance) {
+            await this.waitForInit();
+        }
+        // Call handler method if defined
+        if (this._handlerInstance?.pingActive) {
+            await this._handlerInstance.pingActive(event);
+        }
+        // Call callback if defined
+        await CALL_PING_ACTIVE_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
     }
     ;
     /**
@@ -8053,13 +8177,13 @@ class ActionConnectionService {
          * @param backtest - Whether running in backtest mode
          * @param context - Execution context with action name, strategy name, exchange name, frame name
          */
-        this.breakeven = async (event, backtest, context) => {
-            this.loggerService.log("actionConnectionService breakeven", {
+        this.breakevenAvailable = async (event, backtest, context) => {
+            this.loggerService.log("actionConnectionService breakevenAvailable", {
                 backtest,
                 context,
             });
             const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await action.breakeven(event);
+            await action.breakevenAvailable(event);
         };
         /**
          * Routes partialProfit event to appropriate ClientAction instance.
@@ -8068,13 +8192,13 @@ class ActionConnectionService {
          * @param backtest - Whether running in backtest mode
          * @param context - Execution context with action name, strategy name, exchange name, frame name
          */
-        this.partialProfit = async (event, backtest, context) => {
-            this.loggerService.log("actionConnectionService partialProfit", {
+        this.partialProfitAvailable = async (event, backtest, context) => {
+            this.loggerService.log("actionConnectionService partialProfitAvailable", {
                 backtest,
                 context,
             });
             const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await action.partialProfit(event);
+            await action.partialProfitAvailable(event);
         };
         /**
          * Routes partialLoss event to appropriate ClientAction instance.
@@ -8083,28 +8207,43 @@ class ActionConnectionService {
          * @param backtest - Whether running in backtest mode
          * @param context - Execution context with action name, strategy name, exchange name, frame name
          */
-        this.partialLoss = async (event, backtest, context) => {
-            this.loggerService.log("actionConnectionService partialLoss", {
+        this.partialLossAvailable = async (event, backtest, context) => {
+            this.loggerService.log("actionConnectionService partialLossAvailable", {
                 backtest,
                 context,
             });
             const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await action.partialLoss(event);
+            await action.partialLossAvailable(event);
         };
         /**
-         * Routes ping event to appropriate ClientAction instance.
+         * Routes scheduled ping event to appropriate ClientAction instance.
          *
-         * @param event - Ping event data
+         * @param event - Scheduled ping event data
          * @param backtest - Whether running in backtest mode
          * @param context - Execution context with action name, strategy name, exchange name, frame name
          */
-        this.ping = async (event, backtest, context) => {
-            this.loggerService.log("actionConnectionService ping", {
+        this.pingScheduled = async (event, backtest, context) => {
+            this.loggerService.log("actionConnectionService pingScheduled", {
                 backtest,
                 context,
             });
             const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await action.ping(event);
+            await action.pingScheduled(event);
+        };
+        /**
+         * Routes active ping event to appropriate ClientAction instance.
+         *
+         * @param event - Active ping event data
+         * @param backtest - Whether running in backtest mode
+         * @param context - Execution context with action name, strategy name, exchange name, frame name
+         */
+        this.pingActive = async (event, backtest, context) => {
+            this.loggerService.log("actionConnectionService pingActive", {
+                backtest,
+                context,
+            });
+            const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await action.pingActive(event);
         };
         /**
          * Routes riskRejection event to appropriate ClientAction instance.
@@ -9168,81 +9307,102 @@ class ActionCoreService {
          * Routes breakeven event to all registered actions for the strategy.
          *
          * Retrieves action list from strategy schema (IStrategySchema.actions)
-         * and invokes the breakeven handler on each ClientAction instance sequentially.
+         * and invokes the breakevenAvailable handler on each ClientAction instance sequentially.
          *
          * @param backtest - Whether running in backtest mode (true) or live mode (false)
          * @param event - Breakeven milestone data (stop-loss moved to entry price)
          * @param context - Strategy execution context with strategyName, exchangeName, frameName
          */
-        this.breakeven = async (backtest, event, context) => {
-            this.loggerService.log("actionCoreService breakeven", {
+        this.breakevenAvailable = async (backtest, event, context) => {
+            this.loggerService.log("actionCoreService breakevenAvailable", {
                 context,
             });
             await this.validate(context);
             const { actions = [] } = this.strategySchemaService.get(context.strategyName);
             for (const actionName of actions) {
-                await this.actionConnectionService.breakeven(event, backtest, { actionName, ...context });
+                await this.actionConnectionService.breakevenAvailable(event, backtest, { actionName, ...context });
             }
         };
         /**
          * Routes partial profit event to all registered actions for the strategy.
          *
          * Retrieves action list from strategy schema (IStrategySchema.actions)
-         * and invokes the partialProfit handler on each ClientAction instance sequentially.
+         * and invokes the partialProfitAvailable handler on each ClientAction instance sequentially.
          *
          * @param backtest - Whether running in backtest mode (true) or live mode (false)
          * @param event - Profit milestone data with level (10%, 20%, etc.) and price
          * @param context - Strategy execution context with strategyName, exchangeName, frameName
          */
-        this.partialProfit = async (backtest, event, context) => {
-            this.loggerService.log("actionCoreService partialProfit", {
+        this.partialProfitAvailable = async (backtest, event, context) => {
+            this.loggerService.log("actionCoreService partialProfitAvailable", {
                 context,
             });
             await this.validate(context);
             const { actions = [] } = this.strategySchemaService.get(context.strategyName);
             for (const actionName of actions) {
-                await this.actionConnectionService.partialProfit(event, backtest, { actionName, ...context });
+                await this.actionConnectionService.partialProfitAvailable(event, backtest, { actionName, ...context });
             }
         };
         /**
          * Routes partial loss event to all registered actions for the strategy.
          *
          * Retrieves action list from strategy schema (IStrategySchema.actions)
-         * and invokes the partialLoss handler on each ClientAction instance sequentially.
+         * and invokes the partialLossAvailable handler on each ClientAction instance sequentially.
          *
          * @param backtest - Whether running in backtest mode (true) or live mode (false)
          * @param event - Loss milestone data with level (-10%, -20%, etc.) and price
          * @param context - Strategy execution context with strategyName, exchangeName, frameName
          */
-        this.partialLoss = async (backtest, event, context) => {
-            this.loggerService.log("actionCoreService partialLoss", {
+        this.partialLossAvailable = async (backtest, event, context) => {
+            this.loggerService.log("actionCoreService partialLossAvailable", {
                 context,
             });
             await this.validate(context);
             const { actions = [] } = this.strategySchemaService.get(context.strategyName);
             for (const actionName of actions) {
-                await this.actionConnectionService.partialLoss(event, backtest, { actionName, ...context });
+                await this.actionConnectionService.partialLossAvailable(event, backtest, { actionName, ...context });
             }
         };
         /**
-         * Routes ping event to all registered actions for the strategy.
+         * Routes scheduled ping event to all registered actions for the strategy.
          *
          * Retrieves action list from strategy schema (IStrategySchema.actions)
-         * and invokes the ping handler on each ClientAction instance sequentially.
+         * and invokes the pingScheduled handler on each ClientAction instance sequentially.
          * Called every minute during scheduled signal monitoring.
          *
          * @param backtest - Whether running in backtest mode (true) or live mode (false)
          * @param event - Scheduled signal monitoring data
          * @param context - Strategy execution context with strategyName, exchangeName, frameName
          */
-        this.ping = async (backtest, event, context) => {
-            this.loggerService.log("actionCoreService ping", {
+        this.pingScheduled = async (backtest, event, context) => {
+            this.loggerService.log("actionCoreService pingScheduled", {
+                context,
+            });
+            await this.validate(context);
+            const { actions = [] } = this.strategySchemaService.get(context.strategyName);
+            for (const actionName of actions) {
+                await this.actionConnectionService.pingScheduled(event, backtest, { actionName, ...context });
+            }
+        };
+        /**
+         * Routes active ping event to all registered actions for the strategy.
+         *
+         * Retrieves action list from strategy schema (IStrategySchema.actions)
+         * and invokes the pingActive handler on each ClientAction instance sequentially.
+         * Called every minute during active pending signal monitoring.
+         *
+         * @param backtest - Whether running in backtest mode (true) or live mode (false)
+         * @param event - Active pending signal monitoring data
+         * @param context - Strategy execution context with strategyName, exchangeName, frameName
+         */
+        this.pingActive = async (backtest, event, context) => {
+            this.loggerService.log("actionCoreService pingActive", {
                 context,
             });
             await this.validate(context);
             const { actions = [] } = this.strategySchemaService.get(context.strategyName);
             for (const actionName of actions) {
-                await this.actionConnectionService.ping(event, backtest, { actionName, ...context });
+                await this.actionConnectionService.pingActive(event, backtest, { actionName, ...context });
             }
         };
         /**
@@ -10361,7 +10521,11 @@ class LiveLogicPrivateService {
                 await sleep(TICK_TTL);
                 continue;
             }
-            // Yield opened, closed results
+            if (result.action === "waiting") {
+                await sleep(TICK_TTL);
+                continue;
+            }
+            // Yield opened, closed, cancelled results
             yield result;
             // Check if strategy should stop after signal is closed
             if (result.action === "closed") {
@@ -12296,6 +12460,12 @@ var _a$1, _b$1;
 const MARKDOWN_METHOD_NAME_ENABLE = "MarkdownUtils.enable";
 const MARKDOWN_METHOD_NAME_DISABLE = "MarkdownUtils.disable";
 const MARKDOWN_METHOD_NAME_USE_ADAPTER = "MarkdownAdapter.useMarkdownAdapter";
+const MARKDOWN_METHOD_NAME_FILE_DUMP = "MarkdownFileAdapter.dump";
+const MARKDOWN_METHOD_NAME_FOLDER_DUMP = "MarkdownFolderAdapter.dump";
+const MARKDOWN_METHOD_NAME_WRITE_DATA = "MarkdownAdapter.writeData";
+const MARKDOWN_METHOD_NAME_USE_MD = "MarkdownAdapter.useMd";
+const MARKDOWN_METHOD_NAME_USE_JSONL = "MarkdownAdapter.useJsonl";
+const MARKDOWN_METHOD_NAME_USE_DUMMY = "MarkdownAdapter.useDummy";
 const WAIT_FOR_INIT_SYMBOL$1 = Symbol("wait-for-init");
 const WRITE_SAFE_SYMBOL$1 = Symbol("write-safe");
 /**
@@ -12389,7 +12559,7 @@ class MarkdownFileBase {
      * @throws Error if stream not initialized or write timeout exceeded
      */
     async dump(data, options) {
-        backtest$1.loggerService.debug("MarkdownFileAdapter.dump", {
+        backtest$1.loggerService.debug(MARKDOWN_METHOD_NAME_FILE_DUMP, {
             markdownName: this.markdownName,
             options,
         });
@@ -12471,7 +12641,7 @@ class MarkdownFolderBase {
      * @throws Error if directory creation or file write fails
      */
     async dump(content, options) {
-        backtest$1.loggerService.debug("MarkdownFolderAdapter.dump", {
+        backtest$1.loggerService.debug(MARKDOWN_METHOD_NAME_FOLDER_DUMP, {
             markdownName: this.markdownName,
             options,
         });
@@ -12711,7 +12881,7 @@ class MarkdownAdapter extends MarkdownUtils {
      * @internal - Use service-specific dump methods instead (e.g., Backtest.dump)
      */
     async writeData(markdownName, content, options) {
-        backtest$1.loggerService.debug("MarkdownAdapter.writeData", {
+        backtest$1.loggerService.debug(MARKDOWN_METHOD_NAME_WRITE_DATA, {
             markdownName,
             options,
         });
@@ -12726,7 +12896,7 @@ class MarkdownAdapter extends MarkdownUtils {
      * Each dump creates a separate .md file.
      */
     useMd() {
-        backtest$1.loggerService.debug("MarkdownAdapter.useMd");
+        backtest$1.loggerService.debug(MARKDOWN_METHOD_NAME_USE_MD);
         this.useMarkdownAdapter(MarkdownFolderBase);
     }
     /**
@@ -12735,7 +12905,7 @@ class MarkdownAdapter extends MarkdownUtils {
      * All dumps append to a single .jsonl file per markdown type.
      */
     useJsonl() {
-        backtest$1.loggerService.debug("MarkdownAdapter.useJsonl");
+        backtest$1.loggerService.debug(MARKDOWN_METHOD_NAME_USE_JSONL);
         this.useMarkdownAdapter(MarkdownFileBase);
     }
     /**
@@ -12743,7 +12913,7 @@ class MarkdownAdapter extends MarkdownUtils {
      * All future markdown writes will be no-ops.
      */
     useDummy() {
-        backtest$1.loggerService.debug("MarkdownAdapter.useDummy");
+        backtest$1.loggerService.debug(MARKDOWN_METHOD_NAME_USE_DUMMY);
         this.useMarkdownAdapter(MarkdownDummy);
     }
 }
@@ -13406,6 +13576,98 @@ let ReportStorage$5 = class ReportStorage {
             this._eventList.pop();
         }
     }
+    /**
+     * Adds a scheduled event to the storage.
+     *
+     * @param data - Scheduled tick result
+     */
+    addScheduledEvent(data) {
+        this._eventList.unshift({
+            timestamp: data.signal.scheduledAt,
+            action: "scheduled",
+            symbol: data.signal.symbol,
+            signalId: data.signal.id,
+            position: data.signal.position,
+            note: data.signal.note,
+            currentPrice: data.currentPrice,
+            priceOpen: data.signal.priceOpen,
+            priceTakeProfit: data.signal.priceTakeProfit,
+            priceStopLoss: data.signal.priceStopLoss,
+            originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
+            originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalExecuted: data.signal.totalExecuted,
+        });
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._eventList.length > MAX_EVENTS$6) {
+            this._eventList.pop();
+        }
+    }
+    /**
+     * Adds a waiting event to the storage.
+     * Replaces the last waiting event with the same signalId.
+     *
+     * @param data - Waiting tick result
+     */
+    addWaitingEvent(data) {
+        const newEvent = {
+            timestamp: Date.now(),
+            action: "waiting",
+            symbol: data.signal.symbol,
+            signalId: data.signal.id,
+            position: data.signal.position,
+            note: data.signal.note,
+            currentPrice: data.currentPrice,
+            priceOpen: data.signal.priceOpen,
+            priceTakeProfit: data.signal.priceTakeProfit,
+            priceStopLoss: data.signal.priceStopLoss,
+            originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
+            originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalExecuted: data.signal.totalExecuted,
+            percentTp: data.percentTp,
+            percentSl: data.percentSl,
+            pnl: data.pnl.pnlPercentage,
+        };
+        // Find the last waiting event with the same signalId
+        const lastWaitingIndex = this._eventList.findLastIndex((event) => event.action === "waiting" && event.signalId === data.signal.id);
+        // Replace the last waiting event with the same signalId
+        if (lastWaitingIndex !== -1) {
+            this._eventList[lastWaitingIndex] = newEvent;
+            return;
+        }
+        // If no previous waiting event found, add new event
+        this._eventList.unshift(newEvent);
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._eventList.length > MAX_EVENTS$6) {
+            this._eventList.pop();
+        }
+    }
+    /**
+     * Adds a cancelled event to the storage.
+     *
+     * @param data - Cancelled tick result
+     */
+    addCancelledEvent(data) {
+        this._eventList.unshift({
+            timestamp: data.closeTimestamp,
+            action: "cancelled",
+            symbol: data.signal.symbol,
+            signalId: data.signal.id,
+            position: data.signal.position,
+            note: data.signal.note,
+            currentPrice: data.currentPrice,
+            priceOpen: data.signal.priceOpen,
+            priceTakeProfit: data.signal.priceTakeProfit,
+            priceStopLoss: data.signal.priceStopLoss,
+            originalPriceTakeProfit: data.signal.originalPriceTakeProfit,
+            originalPriceStopLoss: data.signal.originalPriceStopLoss,
+            totalExecuted: data.signal.totalExecuted,
+            cancelReason: data.reason,
+        });
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._eventList.length > MAX_EVENTS$6) {
+            this._eventList.pop();
+        }
+    }
     /**
      * Calculates statistical data from live trading events (Controller).
      * Returns null for any unsafe numeric values (NaN, Infinity, etc).
@@ -13663,6 +13925,12 @@ class LiveMarkdownService {
             if (data.action === "idle") {
                 storage.addIdleEvent(data.currentPrice);
             }
+            else if (data.action === "scheduled") {
+                storage.addScheduledEvent(data);
+            }
+            else if (data.action === "waiting") {
+                storage.addWaitingEvent(data);
+            }
             else if (data.action === "opened") {
                 storage.addOpenedEvent(data);
             }
@@ -13672,6 +13940,9 @@ class LiveMarkdownService {
             else if (data.action === "closed") {
                 storage.addClosedEvent(data);
             }
+            else if (data.action === "cancelled") {
+                storage.addCancelledEvent(data);
+            }
         };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
@@ -18098,7 +18369,7 @@ const CREATE_COMMIT_PROFIT_FN = (self) => async (symbol, strategyName, exchangeN
         timestamp,
     };
     await partialProfitSubject.next(event);
-    await self.actionCoreService.partialProfit(backtest, event, { strategyName, exchangeName, frameName });
+    await self.actionCoreService.partialProfitAvailable(backtest, event, { strategyName, exchangeName, frameName });
 };
 /**
  * Creates a callback function for emitting loss events to partialLossSubject.
@@ -18122,7 +18393,7 @@ const CREATE_COMMIT_LOSS_FN = (self) => async (symbol, strategyName, exchangeNam
         timestamp,
     };
     await partialLossSubject.next(event);
-    await self.actionCoreService.partialLoss(backtest, event, { strategyName, exchangeName, frameName });
+    await self.actionCoreService.partialLossAvailable(backtest, event, { strategyName, exchangeName, frameName });
 };
 /**
  * Connection service for partial profit/loss tracking.
@@ -19271,7 +19542,7 @@ const CREATE_COMMIT_BREAKEVEN_FN = (self) => async (symbol, strategyName, exchan
         timestamp,
     };
     await breakevenSubject.next(event);
-    await self.actionCoreService.breakeven(backtest, event, { strategyName, exchangeName, frameName });
+    await self.actionCoreService.breakevenAvailable(backtest, event, { strategyName, exchangeName, frameName });
 };
 /**
  * Connection service for breakeven tracking.
@@ -21356,6 +21627,43 @@ class LiveReportService {
             if (data.action === "idle") {
                 await Report.writeData("live", baseEvent, searchOptions);
             }
+            else if (data.action === "scheduled") {
+                await Report.writeData("live", {
+                    ...baseEvent,
+                    signalId: data.signal?.id,
+                    position: data.signal?.position,
+                    note: data.signal?.note,
+                    priceOpen: data.signal?.priceOpen,
+                    priceTakeProfit: data.signal?.priceTakeProfit,
+                    priceStopLoss: data.signal?.priceStopLoss,
+                    originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    totalExecuted: data.signal?.totalExecuted,
+                    scheduledAt: data.signal?.scheduledAt,
+                    minuteEstimatedTime: data.signal?.minuteEstimatedTime,
+                }, { ...searchOptions, signalId: data.signal?.id });
+            }
+            else if (data.action === "waiting") {
+                await Report.writeData("live", {
+                    ...baseEvent,
+                    signalId: data.signal?.id,
+                    position: data.signal?.position,
+                    note: data.signal?.note,
+                    priceOpen: data.signal?.priceOpen,
+                    priceTakeProfit: data.signal?.priceTakeProfit,
+                    priceStopLoss: data.signal?.priceStopLoss,
+                    originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    totalExecuted: data.signal?.totalExecuted,
+                    scheduledAt: data.signal?.scheduledAt,
+                    minuteEstimatedTime: data.signal?.minuteEstimatedTime,
+                    percentTp: data.percentTp,
+                    percentSl: data.percentSl,
+                    pnl: data.pnl.pnlPercentage,
+                    pnlPriceOpen: data.pnl.priceOpen,
+                    pnlPriceClose: data.pnl.priceClose,
+                }, { ...searchOptions, signalId: data.signal?.id });
+            }
             else if (data.action === "opened") {
                 await Report.writeData("live", {
                     ...baseEvent,
@@ -21422,6 +21730,24 @@ class LiveReportService {
                     closeTime: data.closeTimestamp,
                 }, { ...searchOptions, signalId: data.signal?.id });
             }
+            else if (data.action === "cancelled") {
+                await Report.writeData("live", {
+                    ...baseEvent,
+                    signalId: data.signal?.id,
+                    position: data.signal?.position,
+                    note: data.signal?.note,
+                    priceOpen: data.signal?.priceOpen,
+                    priceTakeProfit: data.signal?.priceTakeProfit,
+                    priceStopLoss: data.signal?.priceStopLoss,
+                    originalPriceTakeProfit: data.signal?.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.signal?.originalPriceStopLoss,
+                    totalExecuted: data.signal?.totalExecuted,
+                    scheduledAt: data.signal?.scheduledAt,
+                    minuteEstimatedTime: data.signal?.minuteEstimatedTime,
+                    cancelReason: data.reason,
+                    closeTime: data.closeTimestamp,
+                }, { ...searchOptions, signalId: data.signal?.id });
+            }
         };
         /**
          * Subscribes to live signal emitter to receive tick events.
@@ -22611,23 +22937,23 @@ const backtest = {
 init();
 var backtest$1 = backtest;
 
-const GET_TIMEFRAME_METHOD_NAME = "get.getTimeframe";
+const GET_TIMEFRAME_METHOD_NAME = "get.getBacktestTimeframe";
 /**
  * Retrieves current backtest timeframe for given symbol.
  * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
  * @returns Promise resolving to array of Date objects representing tick timestamps
  * @throws Error if called outside of backtest execution context
  */
-async function getCurrentTimeframe(symbol) {
+async function getBacktestTimeframe(symbol) {
     backtest$1.loggerService.info(GET_TIMEFRAME_METHOD_NAME, { symbol });
     if (!ExecutionContextService.hasContext()) {
-        throw new Error("getCurrentTimeframe requires an execution context");
+        throw new Error("getBacktestTimeframe requires an execution context");
     }
     if (!MethodContextService.hasContext()) {
-        throw new Error("getCurrentTimeframe requires a method context");
+        throw new Error("getBacktestTimeframe requires a method context");
     }
     if (!backtest$1.executionContextService.context.backtest) {
-        throw new Error("getCurrentTimeframe can only be used during backtest execution");
+        throw new Error("getBacktestTimeframe can only be used during backtest execution");
     }
     return await backtest$1.frameCoreService.getTimeframe(symbol, backtest$1.methodContextService.context.frameName);
 }
@@ -22827,14 +23153,14 @@ async function validate(args = {}) {
     return await validateInternal(args);
 }
 
-const GET_STRATEGY_METHOD_NAME = "get.getStrategy";
-const GET_EXCHANGE_METHOD_NAME = "get.getExchange";
-const GET_FRAME_METHOD_NAME = "get.getFrame";
-const GET_WALKER_METHOD_NAME = "get.getWalker";
-const GET_SIZING_METHOD_NAME = "get.getSizing";
-const GET_RISK_METHOD_NAME = "get.getRisk";
-const GET_OPTIMIZER_METHOD_NAME = "get.getOptimizer";
-const GET_ACTION_METHOD_NAME = "get.getAction";
+const GET_STRATEGY_METHOD_NAME = "get.getStrategySchema";
+const GET_EXCHANGE_METHOD_NAME = "get.getExchangeSchema";
+const GET_FRAME_METHOD_NAME = "get.getFrameSchema";
+const GET_WALKER_METHOD_NAME = "get.getWalkerSchema";
+const GET_SIZING_METHOD_NAME = "get.getSizingSchema";
+const GET_RISK_METHOD_NAME = "get.getRiskSchema";
+const GET_OPTIMIZER_METHOD_NAME = "get.getOptimizerSchema";
+const GET_ACTION_METHOD_NAME = "get.getActionSchema";
 /**
  * Retrieves a registered strategy schema by name.
  *
@@ -22849,7 +23175,7 @@ const GET_ACTION_METHOD_NAME = "get.getAction";
  * console.log(strategy.getSignal); // async function
  * ```
  */
-function getStrategy(strategyName) {
+function getStrategySchema(strategyName) {
     backtest$1.loggerService.log(GET_STRATEGY_METHOD_NAME, {
         strategyName,
     });
@@ -22870,7 +23196,7 @@ function getStrategy(strategyName) {
  * console.log(exchange.formatPrice); // async function
  * ```
  */
-function getExchange(exchangeName) {
+function getExchangeSchema(exchangeName) {
     backtest$1.loggerService.log(GET_EXCHANGE_METHOD_NAME, {
         exchangeName,
     });
@@ -22892,7 +23218,7 @@ function getExchange(exchangeName) {
  * console.log(frame.endDate); // Date object
  * ```
  */
-function getFrame(frameName) {
+function getFrameSchema(frameName) {
     backtest$1.loggerService.log(GET_FRAME_METHOD_NAME, {
         frameName,
     });
@@ -22915,7 +23241,7 @@ function getFrame(frameName) {
  * console.log(walker.metric); // "sharpeRatio"
  * ```
  */
-function getWalker(walkerName) {
+function getWalkerSchema(walkerName) {
     backtest$1.loggerService.log(GET_WALKER_METHOD_NAME, {
         walkerName,
     });
@@ -22937,7 +23263,7 @@ function getWalker(walkerName) {
  * console.log(sizing.maxPositionPercentage); // 10
  * ```
  */
-function getSizing(sizingName) {
+function getSizingSchema(sizingName) {
     backtest$1.loggerService.log(GET_SIZING_METHOD_NAME, {
         sizingName,
     });
@@ -22958,7 +23284,7 @@ function getSizing(sizingName) {
  * console.log(risk.validations); // Array of validation functions
  * ```
  */
-function getRisk(riskName) {
+function getRiskSchema(riskName) {
     backtest$1.loggerService.log(GET_RISK_METHOD_NAME, {
         riskName,
     });
@@ -22981,7 +23307,7 @@ function getRisk(riskName) {
  * console.log(optimizer.getPrompt); // async function
  * ```
  */
-function getOptimizer(optimizerName) {
+function getOptimizerSchema(optimizerName) {
     backtest$1.loggerService.log(GET_OPTIMIZER_METHOD_NAME, {
         optimizerName,
     });
@@ -23002,7 +23328,7 @@ function getOptimizer(optimizerName) {
  * console.log(action.callbacks); // Optional lifecycle callbacks
  * ```
  */
-function getAction(actionName) {
+function getActionSchema(actionName) {
     backtest$1.loggerService.log(GET_ACTION_METHOD_NAME, {
         actionName,
     });
@@ -23016,6 +23342,8 @@ const FORMAT_PRICE_METHOD_NAME = "exchange.formatPrice";
 const FORMAT_QUANTITY_METHOD_NAME = "exchange.formatQuantity";
 const GET_DATE_METHOD_NAME = "exchange.getDate";
 const GET_MODE_METHOD_NAME = "exchange.getMode";
+const GET_SYMBOL_METHOD_NAME = "exchange.getSymbol";
+const GET_CONTEXT_METHOD_NAME = "exchange.getContext";
 const HAS_TRADE_CONTEXT_METHOD_NAME = "exchange.hasTradeContext";
 const GET_ORDER_BOOK_METHOD_NAME = "exchange.getOrderBook";
 /**
@@ -23198,6 +23526,48 @@ async function getMode() {
     const { backtest: bt } = backtest$1.executionContextService.context;
     return bt ? "backtest" : "live";
 }
+/**
+ * Gets the current trading symbol from execution context.
+ *
+ * @returns Promise resolving to the current trading symbol (e.g., "BTCUSDT")
+ * @throws Error if execution context is not active
+ *
+ * @example
+ * ```typescript
+ * const symbol = await getSymbol();
+ * console.log(symbol); // "BTCUSDT"
+ * ```
+ */
+async function getSymbol() {
+    backtest$1.loggerService.info(GET_SYMBOL_METHOD_NAME);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getSymbol requires an execution context");
+    }
+    const { symbol } = backtest$1.executionContextService.context;
+    return symbol;
+}
+/**
+ * Gets the current method context.
+ *
+ * Returns the context object from the method context service, which contains
+ * information about the current method execution environment.
+ *
+ * @returns Promise resolving to the current method context object
+ * @throws Error if method context is not active
+ *
+ * @example
+ * ```typescript
+ * const context = await getContext();
+ * console.log(context); // { ...method context data... }
+ * ```
+ */
+async function getContext() {
+    backtest$1.loggerService.info(GET_CONTEXT_METHOD_NAME);
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getContext requires a method context");
+    }
+    return backtest$1.methodContextService.context;
+}
 /**
  * Fetches order book for a trading pair from the registered exchange.
  *
@@ -23234,52 +23604,12 @@ async function getOrderBook(symbol, depth) {
     return await backtest$1.exchangeConnectionService.getOrderBook(symbol, depth);
 }
 
-const STOP_METHOD_NAME = "strategy.stop";
-const CANCEL_METHOD_NAME = "strategy.cancel";
-const PARTIAL_PROFIT_METHOD_NAME = "strategy.partialProfit";
-const PARTIAL_LOSS_METHOD_NAME = "strategy.partialLoss";
-const TRAILING_STOP_METHOD_NAME = "strategy.trailingStop";
-const TRAILING_PROFIT_METHOD_NAME = "strategy.trailingTake";
-const BREAKEVEN_METHOD_NAME = "strategy.breakeven";
-/**
- * Stops the strategy from generating new signals.
- *
- * Sets internal flag to prevent strategy from opening new signals.
- * Current active signal (if any) will complete normally.
- * Backtest/Live mode will stop at the next safe point (idle state or after signal closes).
- *
- * Automatically detects backtest/live mode from execution context.
- *
- * @param symbol - Trading pair symbol
- * @param strategyName - Strategy name to stop
- * @returns Promise that resolves when stop flag is set
- *
- * @example
- * ```typescript
- * import { stop } from "backtest-kit";
- *
- * // Stop strategy after some condition
- * await stop("BTCUSDT", "my-strategy");
- * ```
- */
-async function stop(symbol) {
-    backtest$1.loggerService.info(STOP_METHOD_NAME, {
-        symbol,
-    });
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("stop requires an execution context");
-    }
-    if (!MethodContextService.hasContext()) {
-        throw new Error("stop requires a method context");
-    }
-    const { backtest: isBacktest } = backtest$1.executionContextService.context;
-    const { exchangeName, frameName, strategyName } = backtest$1.methodContextService.context;
-    await backtest$1.strategyCoreService.stop(isBacktest, symbol, {
-        exchangeName,
-        frameName,
-        strategyName,
-    });
-}
+const CANCEL_METHOD_NAME = "strategy.commitCancel";
+const PARTIAL_PROFIT_METHOD_NAME = "strategy.commitPartialProfit";
+const PARTIAL_LOSS_METHOD_NAME = "strategy.commitPartialLoss";
+const TRAILING_STOP_METHOD_NAME = "strategy.commitTrailingStop";
+const TRAILING_PROFIT_METHOD_NAME = "strategy.commitTrailingTake";
+const BREAKEVEN_METHOD_NAME = "strategy.commitBreakeven";
 /**
  * Cancels the scheduled signal without stopping the strategy.
  *
@@ -23302,7 +23632,7 @@ async function stop(symbol) {
  * await cancel("BTCUSDT", "my-strategy", "manual-cancel-001");
  * ```
  */
-async function cancel(symbol, cancelId) {
+async function commitCancel(symbol, cancelId) {
     backtest$1.loggerService.info(CANCEL_METHOD_NAME, {
         symbol,
         cancelId,
@@ -23344,7 +23674,7 @@ async function cancel(symbol, cancelId) {
  * }
  * ```
  */
-async function partialProfit(symbol, percentToClose) {
+async function commitPartialProfit(symbol, percentToClose) {
     backtest$1.loggerService.info(PARTIAL_PROFIT_METHOD_NAME, {
         symbol,
         percentToClose,
@@ -23387,7 +23717,7 @@ async function partialProfit(symbol, percentToClose) {
  * }
  * ```
  */
-async function partialLoss(symbol, percentToClose) {
+async function commitPartialLoss(symbol, percentToClose) {
     backtest$1.loggerService.info(PARTIAL_LOSS_METHOD_NAME, {
         symbol,
         percentToClose,
@@ -23446,7 +23776,7 @@ async function partialLoss(symbol, percentToClose) {
  * // success3 = true (ACCEPTED: newDistance = 10% - 7% = 3%, newSL = 97 > 95, better protection)
  * ```
  */
-async function trailingStop(symbol, percentShift, currentPrice) {
+async function commitTrailingStop(symbol, percentShift, currentPrice) {
     backtest$1.loggerService.info(TRAILING_STOP_METHOD_NAME, {
         symbol,
         percentShift,
@@ -23505,7 +23835,7 @@ async function trailingStop(symbol, percentShift, currentPrice) {
  * // success3 = true (ACCEPTED: newDistance = 10% - 5% = 5%, newTP = 105 < 107, more conservative)
  * ```
  */
-async function trailingTake(symbol, percentShift, currentPrice) {
+async function commitTrailingTake(symbol, percentShift, currentPrice) {
     backtest$1.loggerService.info(TRAILING_PROFIT_METHOD_NAME, {
         symbol,
         percentShift,
@@ -23546,7 +23876,7 @@ async function trailingTake(symbol, percentShift, currentPrice) {
  * }
  * ```
  */
-async function breakeven(symbol) {
+async function commitBreakeven(symbol) {
     backtest$1.loggerService.info(BREAKEVEN_METHOD_NAME, {
         symbol,
     });
@@ -23562,6 +23892,47 @@ async function breakeven(symbol) {
     return await backtest$1.strategyCoreService.breakeven(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
 }
 
+const STOP_METHOD_NAME = "control.stop";
+/**
+ * Stops the strategy from generating new signals.
+ *
+ * Sets internal flag to prevent strategy from opening new signals.
+ * Current active signal (if any) will complete normally.
+ * Backtest/Live mode will stop at the next safe point (idle state or after signal closes).
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param strategyName - Strategy name to stop
+ * @returns Promise that resolves when stop flag is set
+ *
+ * @example
+ * ```typescript
+ * import { stop } from "backtest-kit";
+ *
+ * // Stop strategy after some condition
+ * await stop("BTCUSDT", "my-strategy");
+ * ```
+ */
+async function stop(symbol) {
+    backtest$1.loggerService.info(STOP_METHOD_NAME, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("stop requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("stop requires a method context");
+    }
+    const { backtest: isBacktest } = backtest$1.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest$1.methodContextService.context;
+    await backtest$1.strategyCoreService.stop(isBacktest, symbol, {
+        exchangeName,
+        frameName,
+        strategyName,
+    });
+}
+
 /**
  * Sets custom logger implementation for the framework.
  *
@@ -23712,14 +24083,14 @@ function getDefaultColumns() {
     return DEFAULT_COLUMNS;
 }
 
-const ADD_STRATEGY_METHOD_NAME = "add.addStrategy";
-const ADD_EXCHANGE_METHOD_NAME = "add.addExchange";
-const ADD_FRAME_METHOD_NAME = "add.addFrame";
-const ADD_WALKER_METHOD_NAME = "add.addWalker";
-const ADD_SIZING_METHOD_NAME = "add.addSizing";
-const ADD_RISK_METHOD_NAME = "add.addRisk";
-const ADD_OPTIMIZER_METHOD_NAME = "add.addOptimizer";
-const ADD_ACTION_METHOD_NAME = "add.addAction";
+const ADD_STRATEGY_METHOD_NAME = "add.addStrategySchema";
+const ADD_EXCHANGE_METHOD_NAME = "add.addExchangeSchema";
+const ADD_FRAME_METHOD_NAME = "add.addFrameSchema";
+const ADD_WALKER_METHOD_NAME = "add.addWalkerSchema";
+const ADD_SIZING_METHOD_NAME = "add.addSizingSchema";
+const ADD_RISK_METHOD_NAME = "add.addRiskSchema";
+const ADD_OPTIMIZER_METHOD_NAME = "add.addOptimizerSchema";
+const ADD_ACTION_METHOD_NAME = "add.addActionSchema";
 /**
  * Registers a trading strategy in the framework.
  *
@@ -23754,7 +24125,7 @@ const ADD_ACTION_METHOD_NAME = "add.addAction";
  * });
  * ```
  */
-function addStrategy(strategySchema) {
+function addStrategySchema(strategySchema) {
     backtest$1.loggerService.info(ADD_STRATEGY_METHOD_NAME, {
         strategySchema,
     });
@@ -23796,7 +24167,7 @@ function addStrategy(strategySchema) {
  * });
  * ```
  */
-function addExchange(exchangeSchema) {
+function addExchangeSchema(exchangeSchema) {
     backtest$1.loggerService.info(ADD_EXCHANGE_METHOD_NAME, {
         exchangeSchema,
     });
@@ -23833,7 +24204,7 @@ function addExchange(exchangeSchema) {
  * });
  * ```
  */
-function addFrame(frameSchema) {
+function addFrameSchema(frameSchema) {
     backtest$1.loggerService.info(ADD_FRAME_METHOD_NAME, {
         frameSchema,
     });
@@ -23877,7 +24248,7 @@ function addFrame(frameSchema) {
  * });
  * ```
  */
-function addWalker(walkerSchema) {
+function addWalkerSchema(walkerSchema) {
     backtest$1.loggerService.info(ADD_WALKER_METHOD_NAME, {
         walkerSchema,
     });
@@ -23936,7 +24307,7 @@ function addWalker(walkerSchema) {
  * });
  * ```
  */
-function addSizing(sizingSchema) {
+function addSizingSchema(sizingSchema) {
     backtest$1.loggerService.info(ADD_SIZING_METHOD_NAME, {
         sizingSchema,
     });
@@ -24004,7 +24375,7 @@ function addSizing(sizingSchema) {
  * });
  * ```
  */
-function addRisk(riskSchema) {
+function addRiskSchema(riskSchema) {
     backtest$1.loggerService.info(ADD_RISK_METHOD_NAME, {
         riskSchema,
     });
@@ -24098,7 +24469,7 @@ function addRisk(riskSchema) {
  * });
  * ```
  */
-function addOptimizer(optimizerSchema) {
+function addOptimizerSchema(optimizerSchema) {
     backtest$1.loggerService.info(ADD_OPTIMIZER_METHOD_NAME, {
         optimizerSchema,
     });
@@ -24173,7 +24544,7 @@ function addOptimizer(optimizerSchema) {
  * });
  * ```
  */
-function addAction(actionSchema) {
+function addActionSchema(actionSchema) {
     backtest$1.loggerService.info(ADD_ACTION_METHOD_NAME, {
         actionSchema,
     });
@@ -24181,14 +24552,14 @@ function addAction(actionSchema) {
     backtest$1.actionSchemaService.register(actionSchema.actionName, actionSchema);
 }
 
-const METHOD_NAME_OVERRIDE_STRATEGY = "function.override.overrideStrategy";
-const METHOD_NAME_OVERRIDE_EXCHANGE = "function.override.overrideExchange";
-const METHOD_NAME_OVERRIDE_FRAME = "function.override.overrideFrame";
-const METHOD_NAME_OVERRIDE_WALKER = "function.override.overrideWalker";
-const METHOD_NAME_OVERRIDE_SIZING = "function.override.overrideSizing";
-const METHOD_NAME_OVERRIDE_RISK = "function.override.overrideRisk";
-const METHOD_NAME_OVERRIDE_OPTIMIZER = "function.override.overrideOptimizer";
-const METHOD_NAME_OVERRIDE_ACTION = "function.override.overrideAction";
+const METHOD_NAME_OVERRIDE_STRATEGY = "function.override.overrideStrategySchema";
+const METHOD_NAME_OVERRIDE_EXCHANGE = "function.override.overrideExchangeSchema";
+const METHOD_NAME_OVERRIDE_FRAME = "function.override.overrideFrameSchema";
+const METHOD_NAME_OVERRIDE_WALKER = "function.override.overrideWalkerSchema";
+const METHOD_NAME_OVERRIDE_SIZING = "function.override.overrideSizingSchema";
+const METHOD_NAME_OVERRIDE_RISK = "function.override.overrideRiskSchema";
+const METHOD_NAME_OVERRIDE_OPTIMIZER = "function.override.overrideOptimizerSchema";
+const METHOD_NAME_OVERRIDE_ACTION = "function.override.overrideActionSchema";
 /**
  * Overrides an existing trading strategy in the framework.
  *
@@ -24209,7 +24580,7 @@ const METHOD_NAME_OVERRIDE_ACTION = "function.override.overrideAction";
  * });
  * ```
  */
-async function overrideStrategy(strategySchema) {
+async function overrideStrategySchema(strategySchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_STRATEGY, {
         strategySchema,
     });
@@ -24237,7 +24608,7 @@ async function overrideStrategy(strategySchema) {
  * });
  * ```
  */
-async function overrideExchange(exchangeSchema) {
+async function overrideExchangeSchema(exchangeSchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_EXCHANGE, {
         exchangeSchema,
     });
@@ -24265,7 +24636,7 @@ async function overrideExchange(exchangeSchema) {
  * });
  * ```
  */
-async function overrideFrame(frameSchema) {
+async function overrideFrameSchema(frameSchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_FRAME, {
         frameSchema,
     });
@@ -24294,7 +24665,7 @@ async function overrideFrame(frameSchema) {
  * });
  * ```
  */
-async function overrideWalker(walkerSchema) {
+async function overrideWalkerSchema(walkerSchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_WALKER, {
         walkerSchema,
     });
@@ -24326,7 +24697,7 @@ async function overrideWalker(walkerSchema) {
  * });
  * ```
  */
-async function overrideSizing(sizingSchema) {
+async function overrideSizingSchema(sizingSchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_SIZING, {
         sizingSchema,
     });
@@ -24353,7 +24724,7 @@ async function overrideSizing(sizingSchema) {
  * });
  * ```
  */
-async function overrideRisk(riskSchema) {
+async function overrideRiskSchema(riskSchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_RISK, {
         riskSchema,
     });
@@ -24387,7 +24758,7 @@ async function overrideRisk(riskSchema) {
  * });
  * ```
  */
-async function overrideOptimizer(optimizerSchema) {
+async function overrideOptimizerSchema(optimizerSchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_OPTIMIZER, {
         optimizerSchema,
     });
@@ -24454,7 +24825,7 @@ async function overrideOptimizer(optimizerSchema) {
  * });
  * ```
  */
-async function overrideAction(actionSchema) {
+async function overrideActionSchema(actionSchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_ACTION, {
         actionSchema,
     });
@@ -24462,13 +24833,13 @@ async function overrideAction(actionSchema) {
     return backtest$1.actionSchemaService.override(actionSchema.actionName, actionSchema);
 }
 
-const LIST_EXCHANGES_METHOD_NAME = "list.listExchanges";
-const LIST_STRATEGIES_METHOD_NAME = "list.listStrategies";
-const LIST_FRAMES_METHOD_NAME = "list.listFrames";
-const LIST_WALKERS_METHOD_NAME = "list.listWalkers";
-const LIST_SIZINGS_METHOD_NAME = "list.listSizings";
-const LIST_RISKS_METHOD_NAME = "list.listRisks";
-const LIST_OPTIMIZERS_METHOD_NAME = "list.listOptimizers";
+const LIST_EXCHANGES_METHOD_NAME = "list.listExchangeSchema";
+const LIST_STRATEGIES_METHOD_NAME = "list.listStrategySchema";
+const LIST_FRAMES_METHOD_NAME = "list.listFrameSchema";
+const LIST_WALKERS_METHOD_NAME = "list.listWalkerSchema";
+const LIST_SIZINGS_METHOD_NAME = "list.listSizingSchema";
+const LIST_RISKS_METHOD_NAME = "list.listRiskSchema";
+const LIST_OPTIMIZERS_METHOD_NAME = "list.listOptimizerSchema";
 /**
  * Returns a list of all registered exchange schemas.
  *
@@ -24494,7 +24865,7 @@ const LIST_OPTIMIZERS_METHOD_NAME = "list.listOptimizers";
  * // [{ exchangeName: "binance", note: "Binance cryptocurrency exchange", ... }]
  * ```
  */
-async function listExchanges() {
+async function listExchangeSchema() {
     backtest$1.loggerService.log(LIST_EXCHANGES_METHOD_NAME);
     return await backtest$1.exchangeValidationService.list();
 }
@@ -24528,7 +24899,7 @@ async function listExchanges() {
  * // [{ strategyName: "my-strategy", note: "Simple moving average...", ... }]
  * ```
  */
-async function listStrategies() {
+async function listStrategySchema() {
     backtest$1.loggerService.log(LIST_STRATEGIES_METHOD_NAME);
     return await backtest$1.strategyValidationService.list();
 }
@@ -24557,7 +24928,7 @@ async function listStrategies() {
  * // [{ frameName: "1d-backtest", note: "One day backtest...", ... }]
  * ```
  */
-async function listFrames() {
+async function listFrameSchema() {
     backtest$1.loggerService.log(LIST_FRAMES_METHOD_NAME);
     return await backtest$1.frameValidationService.list();
 }
@@ -24587,7 +24958,7 @@ async function listFrames() {
  * // [{ walkerName: "llm-prompt-optimizer", note: "Compare LLM...", ... }]
  * ```
  */
-async function listWalkers() {
+async function listWalkerSchema() {
     backtest$1.loggerService.log(LIST_WALKERS_METHOD_NAME);
     return await backtest$1.walkerValidationService.list();
 }
@@ -24626,7 +24997,7 @@ async function listWalkers() {
  * // ]
  * ```
  */
-async function listSizings() {
+async function listSizingSchema() {
     backtest$1.loggerService.log(LIST_SIZINGS_METHOD_NAME);
     return await backtest$1.sizingValidationService.list();
 }
@@ -24662,7 +25033,7 @@ async function listSizings() {
  * // ]
  * ```
  */
-async function listRisks() {
+async function listRiskSchema() {
     backtest$1.loggerService.log(LIST_RISKS_METHOD_NAME);
     return await backtest$1.riskValidationService.list();
 }
@@ -24702,7 +25073,7 @@ async function listRisks() {
  * // [{ optimizerName: "llm-strategy-generator", note: "Generates...", ... }]
  * ```
  */
-async function listOptimizers() {
+async function listOptimizerSchema() {
     backtest$1.loggerService.log(LIST_OPTIMIZERS_METHOD_NAME);
     return await backtest$1.optimizerValidationService.list();
 }
@@ -24737,8 +25108,10 @@ const LISTEN_BREAKEVEN_METHOD_NAME = "event.listenBreakeven";
 const LISTEN_BREAKEVEN_ONCE_METHOD_NAME = "event.listenBreakevenOnce";
 const LISTEN_RISK_METHOD_NAME = "event.listenRisk";
 const LISTEN_RISK_ONCE_METHOD_NAME = "event.listenRiskOnce";
-const LISTEN_PING_METHOD_NAME = "event.listenPing";
-const LISTEN_PING_ONCE_METHOD_NAME = "event.listenPingOnce";
+const LISTEN_SCHEDULE_PING_METHOD_NAME = "event.listenSchedulePing";
+const LISTEN_SCHEDULE_PING_ONCE_METHOD_NAME = "event.listenSchedulePingOnce";
+const LISTEN_ACTIVE_PING_METHOD_NAME = "event.listenActivePing";
+const LISTEN_ACTIVE_PING_ONCE_METHOD_NAME = "event.listenActivePingOnce";
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -25437,7 +25810,7 @@ function listenValidation(fn) {
  * unsubscribe();
  * ```
  */
-function listenPartialProfit(fn) {
+function listenPartialProfitAvailable(fn) {
     backtest$1.loggerService.log(LISTEN_PARTIAL_PROFIT_METHOD_NAME);
     return partialProfitSubject.subscribe(queued(async (event) => fn(event)));
 }
@@ -25471,7 +25844,7 @@ function listenPartialProfit(fn) {
  * cancel();
  * ```
  */
-function listenPartialProfitOnce(filterFn, fn) {
+function listenPartialProfitAvailableOnce(filterFn, fn) {
     backtest$1.loggerService.log(LISTEN_PARTIAL_PROFIT_ONCE_METHOD_NAME);
     return partialProfitSubject.filter(filterFn).once(fn);
 }
@@ -25499,7 +25872,7 @@ function listenPartialProfitOnce(filterFn, fn) {
  * unsubscribe();
  * ```
  */
-function listenPartialLoss(fn) {
+function listenPartialLossAvailable(fn) {
     backtest$1.loggerService.log(LISTEN_PARTIAL_LOSS_METHOD_NAME);
     return partialLossSubject.subscribe(queued(async (event) => fn(event)));
 }
@@ -25533,7 +25906,7 @@ function listenPartialLoss(fn) {
  * cancel();
  * ```
  */
-function listenPartialLossOnce(filterFn, fn) {
+function listenPartialLossAvailableOnce(filterFn, fn) {
     backtest$1.loggerService.log(LISTEN_PARTIAL_LOSS_ONCE_METHOD_NAME);
     return partialLossSubject.filter(filterFn).once(fn);
 }
@@ -25563,7 +25936,7 @@ function listenPartialLossOnce(filterFn, fn) {
  * unsubscribe();
  * ```
  */
-function listenBreakeven(fn) {
+function listenBreakevenAvailable(fn) {
     backtest$1.loggerService.log(LISTEN_BREAKEVEN_METHOD_NAME);
     return breakevenSubject.subscribe(queued(async (event) => fn(event)));
 }
@@ -25597,7 +25970,7 @@ function listenBreakeven(fn) {
  * cancel();
  * ```
  */
-function listenBreakevenOnce(filterFn, fn) {
+function listenBreakevenAvailableOnce(filterFn, fn) {
     backtest$1.loggerService.log(LISTEN_BREAKEVEN_ONCE_METHOD_NAME);
     return breakevenSubject.filter(filterFn).once(fn);
 }
@@ -25693,9 +26066,9 @@ function listenRiskOnce(filterFn, fn) {
  * unsubscribe();
  * ```
  */
-function listenPing(fn) {
-    backtest$1.loggerService.log(LISTEN_PING_METHOD_NAME);
-    return pingSubject.subscribe(queued(async (event) => fn(event)));
+function listenSchedulePing(fn) {
+    backtest$1.loggerService.log(LISTEN_SCHEDULE_PING_METHOD_NAME);
+    return schedulePingSubject.subscribe(queued(async (event) => fn(event)));
 }
 /**
  * Subscribes to filtered ping events with one-time execution.
@@ -25727,9 +26100,74 @@ function listenPing(fn) {
  * cancel();
  * ```
  */
-function listenPingOnce(filterFn, fn) {
-    backtest$1.loggerService.log(LISTEN_PING_ONCE_METHOD_NAME);
-    return pingSubject.filter(filterFn).once(fn);
+function listenSchedulePingOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_SCHEDULE_PING_ONCE_METHOD_NAME);
+    return schedulePingSubject.filter(filterFn).once(fn);
+}
+/**
+ * Subscribes to active ping events with queued async processing.
+ *
+ * Listens for active pending signal monitoring events emitted every minute.
+ * Useful for tracking active signal lifecycle and implementing dynamic management logic.
+ *
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ *
+ * @param fn - Callback function to handle active ping events
+ * @returns Unsubscribe function to stop listening
+ *
+ * @example
+ * ```typescript
+ * import { listenActivePing } from "./function/event";
+ *
+ * const unsubscribe = listenActivePing((event) => {
+ *   console.log(`[${event.backtest ? "Backtest" : "Live"}] Active Ping`);
+ *   console.log(`Symbol: ${event.symbol}, Strategy: ${event.strategyName}`);
+ *   console.log(`Signal ID: ${event.data.id}, Position: ${event.data.position}`);
+ *   console.log(`Timestamp: ${new Date(event.timestamp).toISOString()}`);
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenActivePing(fn) {
+    backtest$1.loggerService.log(LISTEN_ACTIVE_PING_METHOD_NAME);
+    return activePingSubject.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered active ping events with one-time execution.
+ *
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific active ping conditions.
+ *
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @returns Unsubscribe function to cancel the listener before it fires
+ *
+ * @example
+ * ```typescript
+ * import { listenActivePingOnce } from "./function/event";
+ *
+ * // Wait for first active ping on BTCUSDT
+ * listenActivePingOnce(
+ *   (event) => event.symbol === "BTCUSDT",
+ *   (event) => console.log("First BTCUSDT active ping received")
+ * );
+ *
+ * // Wait for active ping in backtest mode
+ * const cancel = listenActivePingOnce(
+ *   (event) => event.backtest === true,
+ *   (event) => console.log("Backtest active ping received at", new Date(event.timestamp))
+ * );
+ *
+ * // Cancel if needed before event fires
+ * cancel();
+ * ```
+ */
+function listenActivePingOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_ACTIVE_PING_ONCE_METHOD_NAME);
+    return activePingSubject.filter(filterFn).once(fn);
 }
 
 const DUMP_SIGNAL_METHOD_NAME = "dump.dumpSignal";
@@ -25799,7 +26237,7 @@ const DUMP_SIGNAL_METHOD_NAME = "dump.dumpSignal";
  * //          ./dump/strategy/{uuid}/06_llm_output.md (final signal)
  * ```
  */
-async function dumpSignal(signalId, history, signal, outputDir = "./dump/strategy") {
+async function dumpSignalData(signalId, history, signal, outputDir = "./dump/strategy") {
     backtest$1.loggerService.info(DUMP_SIGNAL_METHOD_NAME, {
         signalId,
         history,
@@ -25819,11 +26257,12 @@ const BACKTEST_METHOD_NAME_GET_STATUS = "BacktestUtils.getStatus";
 const BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL = "BacktestUtils.getPendingSignal";
 const BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL = "BacktestUtils.getScheduledSignal";
 const BACKTEST_METHOD_NAME_GET_BREAKEVEN = "BacktestUtils.getBreakeven";
-const BACKTEST_METHOD_NAME_CANCEL = "BacktestUtils.cancel";
-const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.partialProfit";
-const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.partialLoss";
-const BACKTEST_METHOD_NAME_TRAILING_STOP = "BacktestUtils.trailingStop";
-const BACKTEST_METHOD_NAME_TRAILING_PROFIT = "BacktestUtils.trailingTake";
+const BACKTEST_METHOD_NAME_BREAKEVEN = "Backtest.commitBreakeven";
+const BACKTEST_METHOD_NAME_CANCEL = "BacktestUtils.commitCancel";
+const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.commitPartialProfit";
+const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.commitPartialLoss";
+const BACKTEST_METHOD_NAME_TRAILING_STOP = "BacktestUtils.commitTrailingStop";
+const BACKTEST_METHOD_NAME_TRAILING_PROFIT = "BacktestUtils.commitTrailingTake";
 const BACKTEST_METHOD_NAME_GET_DATA = "BacktestUtils.getData";
 /**
  * Internal task function that runs backtest and handles completion.
@@ -26347,14 +26786,14 @@ class BacktestUtils {
          * @example
          * ```typescript
          * // Cancel scheduled signal with custom ID
-         * await Backtest.cancel("BTCUSDT", "my-strategy", {
+         * await Backtest.commitCancel("BTCUSDT", "my-strategy", {
          *   exchangeName: "binance",
          *   frameName: "frame1",
          *   strategyName: "my-strategy"
          * }, "manual-cancel-001");
          * ```
          */
-        this.cancel = async (symbol, context, cancelId) => {
+        this.commitCancel = async (symbol, context, cancelId) => {
             backtest$1.loggerService.info(BACKTEST_METHOD_NAME_CANCEL, {
                 symbol,
                 context,
@@ -26392,7 +26831,7 @@ class BacktestUtils {
          * @example
          * ```typescript
          * // Close 30% of LONG position at profit
-         * const success = await Backtest.partialProfit("BTCUSDT", 30, 45000, {
+         * const success = await Backtest.commitPartialProfit("BTCUSDT", 30, 45000, {
          *   exchangeName: "binance",
          *   frameName: "frame1",
          *   strategyName: "my-strategy"
@@ -26402,7 +26841,7 @@ class BacktestUtils {
          * }
          * ```
          */
-        this.partialProfit = async (symbol, percentToClose, currentPrice, context) => {
+        this.commitPartialProfit = async (symbol, percentToClose, currentPrice, context) => {
             backtest$1.loggerService.info(BACKTEST_METHOD_NAME_PARTIAL_PROFIT, {
                 symbol,
                 percentToClose,
@@ -26441,7 +26880,7 @@ class BacktestUtils {
          * @example
          * ```typescript
          * // Close 40% of LONG position at loss
-         * const success = await Backtest.partialLoss("BTCUSDT", 40, 38000, {
+         * const success = await Backtest.commitPartialLoss("BTCUSDT", 40, 38000, {
          *   exchangeName: "binance",
          *   frameName: "frame1",
          *   strategyName: "my-strategy"
@@ -26451,7 +26890,7 @@ class BacktestUtils {
          * }
          * ```
          */
-        this.partialLoss = async (symbol, percentToClose, currentPrice, context) => {
+        this.commitPartialLoss = async (symbol, percentToClose, currentPrice, context) => {
             backtest$1.loggerService.info(BACKTEST_METHOD_NAME_PARTIAL_LOSS, {
                 symbol,
                 percentToClose,
@@ -26499,7 +26938,7 @@ class BacktestUtils {
          * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
          *
          * // First call: tighten by 5%
-         * await Backtest.trailingStop("BTCUSDT", -5, 102, {
+         * await Backtest.commitTrailingStop("BTCUSDT", -5, 102, {
          *   exchangeName: "binance",
          *   frameName: "frame1",
          *   strategyName: "my-strategy"
@@ -26507,15 +26946,15 @@ class BacktestUtils {
          * // newDistance = 10% - 5% = 5%, newSL = 95
          *
          * // Second call: try weaker protection (smaller percentShift)
-         * await Backtest.trailingStop("BTCUSDT", -3, 102, context);
+         * await Backtest.commitTrailingStop("BTCUSDT", -3, 102, context);
          * // SKIPPED: newSL=97 < 95 (worse protection, larger % absorbs smaller)
          *
          * // Third call: stronger protection (larger percentShift)
-         * await Backtest.trailingStop("BTCUSDT", -7, 102, context);
+         * await Backtest.commitTrailingStop("BTCUSDT", -7, 102, context);
          * // ACCEPTED: newDistance = 10% - 7% = 3%, newSL = 97 > 95 (better protection)
          * ```
          */
-        this.trailingStop = async (symbol, percentShift, currentPrice, context) => {
+        this.commitTrailingStop = async (symbol, percentShift, currentPrice, context) => {
             backtest$1.loggerService.info(BACKTEST_METHOD_NAME_TRAILING_STOP, {
                 symbol,
                 percentShift,
@@ -26563,7 +27002,7 @@ class BacktestUtils {
          * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
          *
          * // First call: bring TP closer by 3%
-         * await Backtest.trailingTake("BTCUSDT", -3, 102, {
+         * await Backtest.commitTrailingTake("BTCUSDT", -3, 102, {
          *   exchangeName: "binance",
          *   frameName: "frame1",
          *   strategyName: "my-strategy"
@@ -26571,15 +27010,15 @@ class BacktestUtils {
          * // newDistance = 10% - 3% = 7%, newTP = 107
          *
          * // Second call: try to move TP further (less conservative)
-         * await Backtest.trailingTake("BTCUSDT", 2, 102, context);
+         * await Backtest.commitTrailingTake("BTCUSDT", 2, 102, context);
          * // SKIPPED: newTP=112 > 107 (less conservative, larger % absorbs smaller)
          *
          * // Third call: even more conservative
-         * await Backtest.trailingTake("BTCUSDT", -5, 102, context);
+         * await Backtest.commitTrailingTake("BTCUSDT", -5, 102, context);
          * // ACCEPTED: newDistance = 10% - 5% = 5%, newTP = 105 < 107 (more conservative)
          * ```
          */
-        this.trailingTake = async (symbol, percentShift, currentPrice, context) => {
+        this.commitTrailingTake = async (symbol, percentShift, currentPrice, context) => {
             backtest$1.loggerService.info(BACKTEST_METHOD_NAME_TRAILING_PROFIT, {
                 symbol,
                 percentShift,
@@ -26612,7 +27051,7 @@ class BacktestUtils {
          *
          * @example
          * ```typescript
-         * const moved = await Backtest.breakeven(
+         * const moved = await Backtest.commitBreakeven(
          *   "BTCUSDT",
          *   112,
          *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" }
@@ -26620,22 +27059,22 @@ class BacktestUtils {
          * console.log(moved); // true (SL moved to entry price)
          * ```
          */
-        this.breakeven = async (symbol, currentPrice, context) => {
-            backtest$1.loggerService.info("Backtest.breakeven", {
+        this.commitBreakeven = async (symbol, currentPrice, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_BREAKEVEN, {
                 symbol,
                 currentPrice,
                 context,
             });
-            backtest$1.strategyValidationService.validate(context.strategyName, "Backtest.breakeven");
-            backtest$1.exchangeValidationService.validate(context.exchangeName, "Backtest.breakeven");
+            backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_BREAKEVEN);
+            backtest$1.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_BREAKEVEN);
             {
                 const { riskName, riskList, actions } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName &&
-                    backtest$1.riskValidationService.validate(riskName, "Backtest.breakeven");
+                    backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_BREAKEVEN);
                 riskList &&
-                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, "Backtest.breakeven"));
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_BREAKEVEN));
                 actions &&
-                    actions.forEach((actionName) => backtest$1.actionValidationService.validate(actionName, "Backtest.breakeven"));
+                    actions.forEach((actionName) => backtest$1.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_BREAKEVEN));
             }
             return await backtest$1.strategyCoreService.breakeven(true, symbol, currentPrice, context);
         };
@@ -26807,11 +27246,12 @@ const LIVE_METHOD_NAME_GET_STATUS = "LiveUtils.getStatus";
 const LIVE_METHOD_NAME_GET_PENDING_SIGNAL = "LiveUtils.getPendingSignal";
 const LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL = "LiveUtils.getScheduledSignal";
 const LIVE_METHOD_NAME_GET_BREAKEVEN = "LiveUtils.getBreakeven";
-const LIVE_METHOD_NAME_CANCEL = "LiveUtils.cancel";
-const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.partialProfit";
-const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.partialLoss";
-const LIVE_METHOD_NAME_TRAILING_STOP = "LiveUtils.trailingStop";
-const LIVE_METHOD_NAME_TRAILING_PROFIT = "LiveUtils.trailingTake";
+const LIVE_METHOD_NAME_BREAKEVEN = "Live.commitBreakeven";
+const LIVE_METHOD_NAME_CANCEL = "LiveUtils.commitCancel";
+const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.commitPartialProfit";
+const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.commitPartialLoss";
+const LIVE_METHOD_NAME_TRAILING_STOP = "LiveUtils.commitTrailingStop";
+const LIVE_METHOD_NAME_TRAILING_PROFIT = "LiveUtils.commitTrailingTake";
 /**
  * Internal task function that runs live trading and handles completion.
  * Consumes live trading results and updates instance state flags.
@@ -27301,14 +27741,14 @@ class LiveUtils {
          * @example
          * ```typescript
          * // Cancel scheduled signal in live trading with custom ID
-         * await Live.cancel("BTCUSDT", "my-strategy", {
+         * await Live.commitCancel("BTCUSDT", "my-strategy", {
          *   exchangeName: "binance",
          *   frameName: "",
          *   strategyName: "my-strategy"
          * }, "manual-cancel-001");
          * ```
          */
-        this.cancel = async (symbol, context, cancelId) => {
+        this.commitCancel = async (symbol, context, cancelId) => {
             backtest$1.loggerService.info(LIVE_METHOD_NAME_CANCEL, {
                 symbol,
                 context,
@@ -27347,7 +27787,7 @@ class LiveUtils {
          * @example
          * ```typescript
          * // Close 30% of LONG position at profit
-         * const success = await Live.partialProfit("BTCUSDT", 30, 45000, {
+         * const success = await Live.commitPartialProfit("BTCUSDT", 30, 45000, {
          *   exchangeName: "binance",
          *   strategyName: "my-strategy"
          * });
@@ -27356,7 +27796,7 @@ class LiveUtils {
          * }
          * ```
          */
-        this.partialProfit = async (symbol, percentToClose, currentPrice, context) => {
+        this.commitPartialProfit = async (symbol, percentToClose, currentPrice, context) => {
             backtest$1.loggerService.info(LIVE_METHOD_NAME_PARTIAL_PROFIT, {
                 symbol,
                 percentToClose,
@@ -27396,7 +27836,7 @@ class LiveUtils {
          * @example
          * ```typescript
          * // Close 40% of LONG position at loss
-         * const success = await Live.partialLoss("BTCUSDT", 40, 38000, {
+         * const success = await Live.commitPartialLoss("BTCUSDT", 40, 38000, {
          *   exchangeName: "binance",
          *   strategyName: "my-strategy"
          * });
@@ -27405,7 +27845,7 @@ class LiveUtils {
          * }
          * ```
          */
-        this.partialLoss = async (symbol, percentToClose, currentPrice, context) => {
+        this.commitPartialLoss = async (symbol, percentToClose, currentPrice, context) => {
             backtest$1.loggerService.info(LIVE_METHOD_NAME_PARTIAL_LOSS, {
                 symbol,
                 percentToClose,
@@ -27454,22 +27894,22 @@ class LiveUtils {
          * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
          *
          * // First call: tighten by 5%
-         * const success1 = await Live.trailingStop("BTCUSDT", -5, 102, {
+         * const success1 = await Live.commitTrailingStop("BTCUSDT", -5, 102, {
          *   exchangeName: "binance",
          *   strategyName: "my-strategy"
          * });
          * // success1 = true, newDistance = 10% - 5% = 5%, newSL = 95
          *
          * // Second call: try weaker protection (smaller percentShift)
-         * const success2 = await Live.trailingStop("BTCUSDT", -3, 102, context);
+         * const success2 = await Live.commitTrailingStop("BTCUSDT", -3, 102, context);
          * // success2 = false (SKIPPED: newSL=97 < 95, worse protection, larger % absorbs smaller)
          *
          * // Third call: stronger protection (larger percentShift)
-         * const success3 = await Live.trailingStop("BTCUSDT", -7, 102, context);
+         * const success3 = await Live.commitTrailingStop("BTCUSDT", -7, 102, context);
          * // success3 = true (ACCEPTED: newDistance = 10% - 7% = 3%, newSL = 97 > 95, better protection)
          * ```
          */
-        this.trailingStop = async (symbol, percentShift, currentPrice, context) => {
+        this.commitTrailingStop = async (symbol, percentShift, currentPrice, context) => {
             backtest$1.loggerService.info(LIVE_METHOD_NAME_TRAILING_STOP, {
                 symbol,
                 percentShift,
@@ -27518,22 +27958,22 @@ class LiveUtils {
          * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
          *
          * // First call: bring TP closer by 3%
-         * const success1 = await Live.trailingTake("BTCUSDT", -3, 102, {
+         * const success1 = await Live.commitTrailingTake("BTCUSDT", -3, 102, {
          *   exchangeName: "binance",
          *   strategyName: "my-strategy"
          * });
          * // success1 = true, newDistance = 10% - 3% = 7%, newTP = 107
          *
          * // Second call: try to move TP further (less conservative)
-         * const success2 = await Live.trailingTake("BTCUSDT", 2, 102, context);
+         * const success2 = await Live.commitTrailingTake("BTCUSDT", 2, 102, context);
          * // success2 = false (SKIPPED: newTP=112 > 107, less conservative, larger % absorbs smaller)
          *
          * // Third call: even more conservative
-         * const success3 = await Live.trailingTake("BTCUSDT", -5, 102, context);
+         * const success3 = await Live.commitTrailingTake("BTCUSDT", -5, 102, context);
          * // success3 = true (ACCEPTED: newDistance = 10% - 5% = 5%, newTP = 105 < 107, more conservative)
          * ```
          */
-        this.trailingTake = async (symbol, percentShift, currentPrice, context) => {
+        this.commitTrailingTake = async (symbol, percentShift, currentPrice, context) => {
             backtest$1.loggerService.info(LIVE_METHOD_NAME_TRAILING_PROFIT, {
                 symbol,
                 percentShift,
@@ -27567,7 +28007,7 @@ class LiveUtils {
          *
          * @example
          * ```typescript
-         * const moved = await Live.breakeven(
+         * const moved = await Live.commitBreakeven(
          *   "BTCUSDT",
          *   112,
          *   { strategyName: "my-strategy", exchangeName: "binance" }
@@ -27575,19 +28015,19 @@ class LiveUtils {
          * console.log(moved); // true (SL moved to entry price)
          * ```
          */
-        this.breakeven = async (symbol, currentPrice, context) => {
-            backtest$1.loggerService.info("Live.breakeven", {
+        this.commitBreakeven = async (symbol, currentPrice, context) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_BREAKEVEN, {
                 symbol,
                 currentPrice,
                 context,
             });
-            backtest$1.strategyValidationService.validate(context.strategyName, "Live.breakeven");
-            backtest$1.exchangeValidationService.validate(context.exchangeName, "Live.breakeven");
+            backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_BREAKEVEN);
+            backtest$1.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_BREAKEVEN);
             {
                 const { riskName, riskList, actions } = backtest$1.strategySchemaService.get(context.strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, "Live.breakeven");
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, "Live.breakeven"));
-                actions && actions.forEach((actionName) => backtest$1.actionValidationService.validate(actionName, "Live.breakeven"));
+                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BREAKEVEN);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BREAKEVEN));
+                actions && actions.forEach((actionName) => backtest$1.actionValidationService.validate(actionName, LIVE_METHOD_NAME_BREAKEVEN));
             }
             return await backtest$1.strategyCoreService.breakeven(false, symbol, currentPrice, {
                 strategyName: context.strategyName,
@@ -29415,10 +29855,15 @@ class ExchangeInstance {
             const whenTimestamp = when.getTime();
             const sinceTimestamp = since.getTime();
             const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp <= whenTimestamp);
-            if (filteredData.length < limit) {
-                backtest$1.loggerService.warn(`ExchangeInstance Expected ${limit} candles, got ${filteredData.length}`);
+            // Apply distinct by timestamp to remove duplicates
+            const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
+            if (filteredData.length !== uniqueData.length) {
+                backtest$1.loggerService.warn(`ExchangeInstance Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`);
             }
-            return filteredData;
+            if (uniqueData.length < limit) {
+                backtest$1.loggerService.warn(`ExchangeInstance Expected ${limit} candles, got ${uniqueData.length}`);
+            }
+            return uniqueData;
         };
         /**
          * Calculates VWAP (Volume Weighted Average Price) from last N 1m candles.
@@ -30597,10 +31042,11 @@ const METHOD_NAME_INIT = "ActionBase.init";
 const METHOD_NAME_EVENT = "ActionBase.event";
 const METHOD_NAME_SIGNAL_LIVE = "ActionBase.signalLive";
 const METHOD_NAME_SIGNAL_BACKTEST = "ActionBase.signalBacktest";
-const METHOD_NAME_BREAKEVEN = "ActionBase.breakeven";
-const METHOD_NAME_PARTIAL_PROFIT = "ActionBase.partialProfit";
-const METHOD_NAME_PARTIAL_LOSS = "ActionBase.partialLoss";
-const METHOD_NAME_PING = "ActionBase.ping";
+const METHOD_NAME_BREAKEVEN_AVAILABLE = "ActionBase.breakevenAvailable";
+const METHOD_NAME_PARTIAL_PROFIT_AVAILABLE = "ActionBase.partialProfitAvailable";
+const METHOD_NAME_PARTIAL_LOSS_AVAILABLE = "ActionBase.partialLossAvailable";
+const METHOD_NAME_PING_SCHEDULED = "ActionBase.pingScheduled";
+const METHOD_NAME_PING_ACTIVE = "ActionBase.pingActive";
 const METHOD_NAME_RISK_REJECTION = "ActionBase.riskRejection";
 const METHOD_NAME_DISPOSE = "ActionBase.dispose";
 const DEFAULT_SOURCE = "default";
@@ -30631,10 +31077,11 @@ const DEFAULT_SOURCE = "default";
  * - signal() - Called on every tick/candle (all modes)
  * - signalLive() - Called only in live mode
  * - signalBacktest() - Called only in backtest mode
- * - breakeven() - Called when SL moved to entry
- * - partialProfit() - Called on profit milestones (10%, 20%, etc.)
- * - partialLoss() - Called on loss milestones (-10%, -20%, etc.)
- * - ping() - Called every minute during scheduled signal monitoring
+ * - breakevenAvailable() - Called when SL moved to entry
+ * - partialProfitAvailable() - Called on profit milestones (10%, 20%, etc.)
+ * - partialLossAvailable() - Called on loss milestones (-10%, -20%, etc.)
+ * - pingScheduled() - Called every minute during scheduled signal monitoring
+ * - pingActive() - Called every minute during active pending signal monitoring
  * - riskRejection() - Called when signal rejected by risk management
  *
  * @example
@@ -30675,7 +31122,7 @@ const DEFAULT_SOURCE = "default";
  * }
  *
  * // Register the action
- * addAction({
+ * addActionSchema({
  *   actionName: "telegram-notifier",
  *   handler: TelegramNotifier
  * });
@@ -30717,11 +31164,13 @@ class ActionBase {
      * @param strategyName - Strategy identifier this action is attached to
      * @param frameName - Timeframe identifier this action is attached to
      * @param actionName - Action identifier
+     * @param backtest - If running in backtest
      */
-    constructor(strategyName, frameName, actionName) {
+    constructor(strategyName, frameName, actionName, backtest) {
         this.strategyName = strategyName;
         this.frameName = frameName;
         this.actionName = actionName;
+        this.backtest = backtest;
     }
     /**
      * Initializes the action handler.
@@ -30845,7 +31294,7 @@ class ActionBase {
      * Called once per signal when price moves far enough to cover fees and slippage.
      * Breakeven threshold: (CC_PERCENT_SLIPPAGE + CC_PERCENT_FEE) * 2 + CC_BREAKEVEN_THRESHOLD
      *
-     * Triggered by: ActionCoreService.breakeven() via BreakevenConnectionService
+     * Triggered by: ActionCoreService.breakevenAvailable() via BreakevenConnectionService
      * Source: breakevenSubject.next() in CREATE_COMMIT_BREAKEVEN_FN callback
      * Frequency: Once per signal when threshold reached
      *
@@ -30855,7 +31304,7 @@ class ActionBase {
      *
      * @example
      * ```typescript
-     * async breakeven(event: BreakevenContract) {
+     * async breakevenAvailable(event: BreakevenContract) {
      *   await this.telegram.send(
      *     `[${event.strategyName}] Breakeven reached! ` +
      *     `Signal: ${event.data.side} @ ${event.currentPrice}`
@@ -30863,8 +31312,8 @@ class ActionBase {
      * }
      * ```
      */
-    breakeven(event, source = DEFAULT_SOURCE) {
-        backtest$1.loggerService.info(METHOD_NAME_BREAKEVEN, {
+    breakevenAvailable(event, source = DEFAULT_SOURCE) {
+        backtest$1.loggerService.info(METHOD_NAME_BREAKEVEN_AVAILABLE, {
             event,
             source,
         });
@@ -30875,7 +31324,7 @@ class ActionBase {
      * Called once per profit level per signal (deduplicated).
      * Use to track profit milestones and adjust position management.
      *
-     * Triggered by: ActionCoreService.partialProfit() via PartialConnectionService
+     * Triggered by: ActionCoreService.partialProfitAvailable() via PartialConnectionService
      * Source: partialProfitSubject.next() in CREATE_COMMIT_PROFIT_FN callback
      * Frequency: Once per profit level per signal
      *
@@ -30885,7 +31334,7 @@ class ActionBase {
      *
      * @example
      * ```typescript
-     * async partialProfit(event: PartialProfitContract) {
+     * async partialProfitAvailable(event: PartialProfitContract) {
      *   await this.telegram.send(
      *     `[${event.strategyName}] Profit ${event.level}% reached! ` +
      *     `Current price: ${event.currentPrice}`
@@ -30894,8 +31343,8 @@ class ActionBase {
      * }
      * ```
      */
-    partialProfit(event, source = DEFAULT_SOURCE) {
-        backtest$1.loggerService.info(METHOD_NAME_PARTIAL_PROFIT, {
+    partialProfitAvailable(event, source = DEFAULT_SOURCE) {
+        backtest$1.loggerService.info(METHOD_NAME_PARTIAL_PROFIT_AVAILABLE, {
             event,
             source,
         });
@@ -30906,7 +31355,7 @@ class ActionBase {
      * Called once per loss level per signal (deduplicated).
      * Use to track loss milestones and implement risk management actions.
      *
-     * Triggered by: ActionCoreService.partialLoss() via PartialConnectionService
+     * Triggered by: ActionCoreService.partialLossAvailable() via PartialConnectionService
      * Source: partialLossSubject.next() in CREATE_COMMIT_LOSS_FN callback
      * Frequency: Once per loss level per signal
      *
@@ -30916,7 +31365,7 @@ class ActionBase {
      *
      * @example
      * ```typescript
-     * async partialLoss(event: PartialLossContract) {
+     * async partialLossAvailable(event: PartialLossContract) {
      *   await this.telegram.send(
      *     `[${event.strategyName}] Loss ${event.level}% reached! ` +
      *     `Current price: ${event.currentPrice}`
@@ -30925,37 +31374,66 @@ class ActionBase {
      * }
      * ```
      */
-    partialLoss(event, source = DEFAULT_SOURCE) {
-        backtest$1.loggerService.info(METHOD_NAME_PARTIAL_LOSS, {
+    partialLossAvailable(event, source = DEFAULT_SOURCE) {
+        backtest$1.loggerService.info(METHOD_NAME_PARTIAL_LOSS_AVAILABLE, {
             event,
             source,
         });
     }
     /**
-     * Handles ping events during scheduled signal monitoring.
+     * Handles scheduled ping events during scheduled signal monitoring.
      *
      * Called every minute while a scheduled signal is waiting for activation.
      * Use to monitor pending signals and track wait time.
      *
-     * Triggered by: ActionCoreService.ping() via StrategyConnectionService
-     * Source: pingSubject.next() in CREATE_COMMIT_PING_FN callback
+     * Triggered by: ActionCoreService.pingScheduled() via StrategyConnectionService
+     * Source: schedulePingSubject.next() in CREATE_COMMIT_SCHEDULE_PING_FN callback
      * Frequency: Every minute while scheduled signal is waiting
      *
-     * Default implementation: Logs ping event.
+     * Default implementation: Logs scheduled ping event.
      *
      * @param event - Scheduled signal monitoring data with symbol, strategy info, signal data, timestamp
      *
      * @example
      * ```typescript
-     * ping(event: PingContract) {
+     * pingScheduled(event: SchedulePingContract) {
      *   const waitTime = Date.now() - event.data.timestampScheduled;
      *   const waitMinutes = Math.floor(waitTime / 60000);
      *   console.log(`Scheduled signal waiting ${waitMinutes} minutes`);
      * }
      * ```
      */
-    ping(event, source = DEFAULT_SOURCE) {
-        backtest$1.loggerService.info(METHOD_NAME_PING, {
+    pingScheduled(event, source = DEFAULT_SOURCE) {
+        backtest$1.loggerService.info(METHOD_NAME_PING_SCHEDULED, {
+            event,
+            source,
+        });
+    }
+    /**
+     * Handles active ping events during active pending signal monitoring.
+     *
+     * Called every minute while a pending signal is active (position open).
+     * Use to monitor active positions and track lifecycle.
+     *
+     * Triggered by: ActionCoreService.pingActive() via StrategyConnectionService
+     * Source: activePingSubject.next() in CREATE_COMMIT_ACTIVE_PING_FN callback
+     * Frequency: Every minute while pending signal is active
+     *
+     * Default implementation: Logs active ping event.
+     *
+     * @param event - Active pending signal monitoring data with symbol, strategy info, signal data, timestamp
+     *
+     * @example
+     * ```typescript
+     * pingActive(event: ActivePingContract) {
+     *   const holdTime = Date.now() - event.data.pendingAt;
+     *   const holdMinutes = Math.floor(holdTime / 60000);
+     *   console.log(`Active signal holding ${holdMinutes} minutes`);
+     * }
+     * ```
+     */
+    pingActive(event, source = DEFAULT_SOURCE) {
+        backtest$1.loggerService.info(METHOD_NAME_PING_ACTIVE, {
             event,
             source,
         });
@@ -31074,4 +31552,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Walker, addAction, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, breakeven, cancel, dumpSignal, emitters, formatPrice, formatQuantity, get, getAction, getAveragePrice, getCandles, getColumns, getConfig, getCurrentTimeframe, getDate, getDefaultColumns, getDefaultConfig, getExchange, getFrame, getMode, getOptimizer, getOrderBook, getRisk, getSizing, getStrategy, getWalker, hasTradeContext, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenBreakeven, listenBreakevenOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenPing, listenPingOnce, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideAction, overrideExchange, overrideFrame, overrideOptimizer, overrideRisk, overrideSizing, overrideStrategy, overrideWalker, partialLoss, partialProfit, roundTicks, set, setColumns, setConfig, setLogger, stop, trailingStop, trailingTake, validate };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addOptimizerSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancel, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, dumpSignalData, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOptimizerSchema, getOrderBook, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listOptimizerSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideOptimizerSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, roundTicks, set, setColumns, setConfig, setLogger, stop, validate };