backtest-kit 1.13.4 → 2.0.1

package/build/index.cjs

@@ -541,14 +541,21 @@ const breakevenSubject = new functoolsKit.Subject();
  */
 const riskSubject = new functoolsKit.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 functoolsKit.Subject();
+const schedulePingSubject = new functoolsKit.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 functoolsKit.Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    activePingSubject: activePingSubject,
     breakevenSubject: breakevenSubject,
     doneBacktestSubject: doneBacktestSubject,
     doneLiveSubject: doneLiveSubject,
@@ -558,11 +565,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,
@@ -773,11 +780,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.
@@ -826,11 +838,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.
@@ -3406,14 +3423,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 = functoolsKit.trycatch(beginTime(async (self, symbol, scheduled, timestamp, backtest) => {
+const CALL_SCHEDULE_PING_CALLBACKS_FN = functoolsKit.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),
@@ -3422,7 +3439,33 @@ const CALL_PING_CALLBACKS_FN = functoolsKit.trycatch(beginTime(async (self, symb
     });
 }), {
     fallback: (error) => {
-        const message = "ClientStrategy CALL_PING_CALLBACKS_FN thrown";
+        const message = "ClientStrategy CALL_SCHEDULE_PING_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_ACTIVE_PING_CALLBACKS_FN = functoolsKit.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: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
@@ -3794,10 +3837,10 @@ const CALL_BREAKEVEN_CLEAR_FN = functoolsKit.trycatch(beginTime(async (self, sym
 });
 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,
@@ -3924,6 +3967,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") {
@@ -4129,7 +4173,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 };
         }
@@ -4186,7 +4230,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,
@@ -4212,6 +4256,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 (КРИТИЧНО!)
@@ -4757,7 +4802,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);
@@ -4773,35 +4826,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(functoolsKit.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;
@@ -4831,9 +4872,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(functoolsKit.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);
     }
     /**
@@ -5622,6 +5683,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.
  *
@@ -5677,7 +5741,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)) {
@@ -5701,7 +5765,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,
         });
@@ -5718,7 +5782,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,
         });
@@ -6001,15 +6065,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,
@@ -6018,8 +6082,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.
@@ -6116,7 +6201,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),
             });
         });
@@ -7509,8 +7595,8 @@ const CALL_SIGNAL_BACKTEST_CALLBACK_FN = functoolsKit.trycatch(async (self, even
 });
 /** Wrapper to call breakeven callback with error handling */
 const CALL_BREAKEVEN_CALLBACK_FN = functoolsKit.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) => {
@@ -7526,8 +7612,8 @@ const CALL_BREAKEVEN_CALLBACK_FN = functoolsKit.trycatch(async (self, event, str
 });
 /** Wrapper to call partialProfit callback with error handling */
 const CALL_PARTIAL_PROFIT_CALLBACK_FN = functoolsKit.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) => {
@@ -7543,8 +7629,8 @@ const CALL_PARTIAL_PROFIT_CALLBACK_FN = functoolsKit.trycatch(async (self, event
 });
 /** Wrapper to call partialLoss callback with error handling */
 const CALL_PARTIAL_LOSS_CALLBACK_FN = functoolsKit.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) => {
@@ -7558,14 +7644,31 @@ const CALL_PARTIAL_LOSS_CALLBACK_FN = functoolsKit.trycatch(async (self, event,
         errorEmitter.next(error);
     },
 });
-/** Wrapper to call ping callback with error handling */
-const CALL_PING_CALLBACK_FN = functoolsKit.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 = functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.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 = functoolsKit.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: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
@@ -7640,6 +7743,7 @@ const CREATE_HANDLER_FN = (self) => {
             self.params.strategyName,
             self.params.frameName,
             self.params.actionName,
+            self.params.backtest,
         ]);
     }
     return self.params.handler;
@@ -7831,8 +7935,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,
@@ -7841,8 +7945,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);
@@ -7851,8 +7955,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,
@@ -7861,8 +7965,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);
@@ -7871,8 +7975,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,
@@ -7881,18 +7985,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,
@@ -7901,11 +8005,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);
     }
     ;
     /**
@@ -8073,13 +8197,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.
@@ -8088,13 +8212,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.
@@ -8103,28 +8227,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.
@@ -9188,81 +9327,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 });
             }
         };
         /**
@@ -10381,7 +10541,11 @@ class LiveLogicPrivateService {
                 await functoolsKit.sleep(TICK_TTL);
                 continue;
             }
-            // Yield opened, closed results
+            if (result.action === "waiting") {
+                await functoolsKit.sleep(TICK_TTL);
+                continue;
+            }
+            // Yield opened, closed, cancelled results
             yield result;
             // Check if strategy should stop after signal is closed
             if (result.action === "closed") {
@@ -12316,6 +12480,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");
 /**
@@ -12409,7 +12579,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,
         });
@@ -12491,7 +12661,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,
         });
@@ -12731,7 +12901,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,
         });
@@ -12746,7 +12916,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);
     }
     /**
@@ -12755,7 +12925,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);
     }
     /**
@@ -12763,7 +12933,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);
     }
 }
@@ -13426,6 +13596,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).
@@ -13683,6 +13945,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);
             }
@@ -13692,6 +13960,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.
@@ -18118,7 +18389,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.
@@ -18142,7 +18413,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.
@@ -19291,7 +19562,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.
@@ -21376,6 +21647,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,
@@ -21442,6 +21750,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.
@@ -22631,23 +22957,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);
 }
@@ -22847,14 +23173,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.
  *
@@ -22869,7 +23195,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,
     });
@@ -22890,7 +23216,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,
     });
@@ -22912,7 +23238,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,
     });
@@ -22935,7 +23261,7 @@ function getFrame(frameName) {
  * console.log(walker.metric); // "sharpeRatio"
  * ```
  */
-function getWalker(walkerName) {
+function getWalkerSchema(walkerName) {
     backtest$1.loggerService.log(GET_WALKER_METHOD_NAME, {
         walkerName,
     });
@@ -22957,7 +23283,7 @@ function getWalker(walkerName) {
  * console.log(sizing.maxPositionPercentage); // 10
  * ```
  */
-function getSizing(sizingName) {
+function getSizingSchema(sizingName) {
     backtest$1.loggerService.log(GET_SIZING_METHOD_NAME, {
         sizingName,
     });
@@ -22978,7 +23304,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,
     });
@@ -23001,7 +23327,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,
     });
@@ -23022,7 +23348,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,
     });
@@ -23036,6 +23362,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";
 /**
@@ -23218,6 +23546,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.
  *
@@ -23254,52 +23624,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.
  *
@@ -23322,7 +23652,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,
@@ -23364,7 +23694,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,
@@ -23407,7 +23737,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,
@@ -23466,7 +23796,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,
@@ -23525,7 +23855,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,
@@ -23566,7 +23896,7 @@ async function trailingTake(symbol, percentShift, currentPrice) {
  * }
  * ```
  */
-async function breakeven(symbol) {
+async function commitBreakeven(symbol) {
     backtest$1.loggerService.info(BREAKEVEN_METHOD_NAME, {
         symbol,
     });
@@ -23582,6 +23912,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.
  *
@@ -23732,14 +24103,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.
  *
@@ -23774,7 +24145,7 @@ const ADD_ACTION_METHOD_NAME = "add.addAction";
  * });
  * ```
  */
-function addStrategy(strategySchema) {
+function addStrategySchema(strategySchema) {
     backtest$1.loggerService.info(ADD_STRATEGY_METHOD_NAME, {
         strategySchema,
     });
@@ -23816,7 +24187,7 @@ function addStrategy(strategySchema) {
  * });
  * ```
  */
-function addExchange(exchangeSchema) {
+function addExchangeSchema(exchangeSchema) {
     backtest$1.loggerService.info(ADD_EXCHANGE_METHOD_NAME, {
         exchangeSchema,
     });
@@ -23853,7 +24224,7 @@ function addExchange(exchangeSchema) {
  * });
  * ```
  */
-function addFrame(frameSchema) {
+function addFrameSchema(frameSchema) {
     backtest$1.loggerService.info(ADD_FRAME_METHOD_NAME, {
         frameSchema,
     });
@@ -23897,7 +24268,7 @@ function addFrame(frameSchema) {
  * });
  * ```
  */
-function addWalker(walkerSchema) {
+function addWalkerSchema(walkerSchema) {
     backtest$1.loggerService.info(ADD_WALKER_METHOD_NAME, {
         walkerSchema,
     });
@@ -23956,7 +24327,7 @@ function addWalker(walkerSchema) {
  * });
  * ```
  */
-function addSizing(sizingSchema) {
+function addSizingSchema(sizingSchema) {
     backtest$1.loggerService.info(ADD_SIZING_METHOD_NAME, {
         sizingSchema,
     });
@@ -24024,7 +24395,7 @@ function addSizing(sizingSchema) {
  * });
  * ```
  */
-function addRisk(riskSchema) {
+function addRiskSchema(riskSchema) {
     backtest$1.loggerService.info(ADD_RISK_METHOD_NAME, {
         riskSchema,
     });
@@ -24118,7 +24489,7 @@ function addRisk(riskSchema) {
  * });
  * ```
  */
-function addOptimizer(optimizerSchema) {
+function addOptimizerSchema(optimizerSchema) {
     backtest$1.loggerService.info(ADD_OPTIMIZER_METHOD_NAME, {
         optimizerSchema,
     });
@@ -24193,7 +24564,7 @@ function addOptimizer(optimizerSchema) {
  * });
  * ```
  */
-function addAction(actionSchema) {
+function addActionSchema(actionSchema) {
     backtest$1.loggerService.info(ADD_ACTION_METHOD_NAME, {
         actionSchema,
     });
@@ -24201,14 +24572,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.
  *
@@ -24229,7 +24600,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,
     });
@@ -24257,7 +24628,7 @@ async function overrideStrategy(strategySchema) {
  * });
  * ```
  */
-async function overrideExchange(exchangeSchema) {
+async function overrideExchangeSchema(exchangeSchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_EXCHANGE, {
         exchangeSchema,
     });
@@ -24285,7 +24656,7 @@ async function overrideExchange(exchangeSchema) {
  * });
  * ```
  */
-async function overrideFrame(frameSchema) {
+async function overrideFrameSchema(frameSchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_FRAME, {
         frameSchema,
     });
@@ -24314,7 +24685,7 @@ async function overrideFrame(frameSchema) {
  * });
  * ```
  */
-async function overrideWalker(walkerSchema) {
+async function overrideWalkerSchema(walkerSchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_WALKER, {
         walkerSchema,
     });
@@ -24346,7 +24717,7 @@ async function overrideWalker(walkerSchema) {
  * });
  * ```
  */
-async function overrideSizing(sizingSchema) {
+async function overrideSizingSchema(sizingSchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_SIZING, {
         sizingSchema,
     });
@@ -24373,7 +24744,7 @@ async function overrideSizing(sizingSchema) {
  * });
  * ```
  */
-async function overrideRisk(riskSchema) {
+async function overrideRiskSchema(riskSchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_RISK, {
         riskSchema,
     });
@@ -24407,7 +24778,7 @@ async function overrideRisk(riskSchema) {
  * });
  * ```
  */
-async function overrideOptimizer(optimizerSchema) {
+async function overrideOptimizerSchema(optimizerSchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_OPTIMIZER, {
         optimizerSchema,
     });
@@ -24474,7 +24845,7 @@ async function overrideOptimizer(optimizerSchema) {
  * });
  * ```
  */
-async function overrideAction(actionSchema) {
+async function overrideActionSchema(actionSchema) {
     backtest$1.loggerService.log(METHOD_NAME_OVERRIDE_ACTION, {
         actionSchema,
     });
@@ -24482,13 +24853,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.
  *
@@ -24514,7 +24885,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();
 }
@@ -24548,7 +24919,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();
 }
@@ -24577,7 +24948,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();
 }
@@ -24607,7 +24978,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();
 }
@@ -24646,7 +25017,7 @@ async function listWalkers() {
  * // ]
  * ```
  */
-async function listSizings() {
+async function listSizingSchema() {
     backtest$1.loggerService.log(LIST_SIZINGS_METHOD_NAME);
     return await backtest$1.sizingValidationService.list();
 }
@@ -24682,7 +25053,7 @@ async function listSizings() {
  * // ]
  * ```
  */
-async function listRisks() {
+async function listRiskSchema() {
     backtest$1.loggerService.log(LIST_RISKS_METHOD_NAME);
     return await backtest$1.riskValidationService.list();
 }
@@ -24722,7 +25093,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();
 }
@@ -24757,8 +25128,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.
  *
@@ -25457,7 +25830,7 @@ function listenValidation(fn) {
  * unsubscribe();
  * ```
  */
-function listenPartialProfit(fn) {
+function listenPartialProfitAvailable(fn) {
     backtest$1.loggerService.log(LISTEN_PARTIAL_PROFIT_METHOD_NAME);
     return partialProfitSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
@@ -25491,7 +25864,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);
 }
@@ -25519,7 +25892,7 @@ function listenPartialProfitOnce(filterFn, fn) {
  * unsubscribe();
  * ```
  */
-function listenPartialLoss(fn) {
+function listenPartialLossAvailable(fn) {
     backtest$1.loggerService.log(LISTEN_PARTIAL_LOSS_METHOD_NAME);
     return partialLossSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
@@ -25553,7 +25926,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);
 }
@@ -25583,7 +25956,7 @@ function listenPartialLossOnce(filterFn, fn) {
  * unsubscribe();
  * ```
  */
-function listenBreakeven(fn) {
+function listenBreakevenAvailable(fn) {
     backtest$1.loggerService.log(LISTEN_BREAKEVEN_METHOD_NAME);
     return breakevenSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
@@ -25617,7 +25990,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);
 }
@@ -25713,9 +26086,9 @@ function listenRiskOnce(filterFn, fn) {
  * unsubscribe();
  * ```
  */
-function listenPing(fn) {
-    backtest$1.loggerService.log(LISTEN_PING_METHOD_NAME);
-    return pingSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
+function listenSchedulePing(fn) {
+    backtest$1.loggerService.log(LISTEN_SCHEDULE_PING_METHOD_NAME);
+    return schedulePingSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
  * Subscribes to filtered ping events with one-time execution.
@@ -25747,9 +26120,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(functoolsKit.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";
@@ -25819,7 +26257,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,
@@ -25839,11 +26277,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.
@@ -26367,14 +26806,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,
@@ -26412,7 +26851,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"
@@ -26422,7 +26861,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,
@@ -26461,7 +26900,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"
@@ -26471,7 +26910,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,
@@ -26519,7 +26958,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"
@@ -26527,15 +26966,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,
@@ -26583,7 +27022,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"
@@ -26591,15 +27030,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,
@@ -26632,7 +27071,7 @@ class BacktestUtils {
          *
          * @example
          * ```typescript
-         * const moved = await Backtest.breakeven(
+         * const moved = await Backtest.commitBreakeven(
          *   "BTCUSDT",
          *   112,
          *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" }
@@ -26640,22 +27079,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);
         };
@@ -26827,11 +27266,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.
@@ -27321,14 +27761,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,
@@ -27367,7 +27807,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"
          * });
@@ -27376,7 +27816,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,
@@ -27416,7 +27856,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"
          * });
@@ -27425,7 +27865,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,
@@ -27474,22 +27914,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,
@@ -27538,22 +27978,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,
@@ -27587,7 +28027,7 @@ class LiveUtils {
          *
          * @example
          * ```typescript
-         * const moved = await Live.breakeven(
+         * const moved = await Live.commitBreakeven(
          *   "BTCUSDT",
          *   112,
          *   { strategyName: "my-strategy", exchangeName: "binance" }
@@ -27595,19 +28035,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,
@@ -29435,10 +29875,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.
@@ -30617,10 +31062,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";
@@ -30651,10 +31097,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
@@ -30695,7 +31142,7 @@ const DEFAULT_SOURCE = "default";
  * }
  *
  * // Register the action
- * addAction({
+ * addActionSchema({
  *   actionName: "telegram-notifier",
  *   handler: TelegramNotifier
  * });
@@ -30737,11 +31184,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.
@@ -30865,7 +31314,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
      *
@@ -30875,7 +31324,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}`
@@ -30883,8 +31332,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,
         });
@@ -30895,7 +31344,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
      *
@@ -30905,7 +31354,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}`
@@ -30914,8 +31363,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,
         });
@@ -30926,7 +31375,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
      *
@@ -30936,7 +31385,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}`
@@ -30945,37 +31394,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,
         });
@@ -31123,51 +31601,59 @@ exports.ReportBase = ReportBase;
 exports.Risk = Risk;
 exports.Schedule = Schedule;
 exports.Walker = Walker;
-exports.addAction = addAction;
-exports.addExchange = addExchange;
-exports.addFrame = addFrame;
-exports.addOptimizer = addOptimizer;
-exports.addRisk = addRisk;
-exports.addSizing = addSizing;
-exports.addStrategy = addStrategy;
-exports.addWalker = addWalker;
-exports.breakeven = breakeven;
-exports.cancel = cancel;
-exports.dumpSignal = dumpSignal;
+exports.addActionSchema = addActionSchema;
+exports.addExchangeSchema = addExchangeSchema;
+exports.addFrameSchema = addFrameSchema;
+exports.addOptimizerSchema = addOptimizerSchema;
+exports.addRiskSchema = addRiskSchema;
+exports.addSizingSchema = addSizingSchema;
+exports.addStrategySchema = addStrategySchema;
+exports.addWalkerSchema = addWalkerSchema;
+exports.commitBreakeven = commitBreakeven;
+exports.commitCancel = commitCancel;
+exports.commitPartialLoss = commitPartialLoss;
+exports.commitPartialProfit = commitPartialProfit;
+exports.commitTrailingStop = commitTrailingStop;
+exports.commitTrailingTake = commitTrailingTake;
+exports.dumpSignalData = dumpSignalData;
 exports.emitters = emitters;
 exports.formatPrice = formatPrice;
 exports.formatQuantity = formatQuantity;
 exports.get = get;
-exports.getAction = getAction;
+exports.getActionSchema = getActionSchema;
 exports.getAveragePrice = getAveragePrice;
+exports.getBacktestTimeframe = getBacktestTimeframe;
 exports.getCandles = getCandles;
 exports.getColumns = getColumns;
 exports.getConfig = getConfig;
-exports.getCurrentTimeframe = getCurrentTimeframe;
+exports.getContext = getContext;
 exports.getDate = getDate;
 exports.getDefaultColumns = getDefaultColumns;
 exports.getDefaultConfig = getDefaultConfig;
-exports.getExchange = getExchange;
-exports.getFrame = getFrame;
+exports.getExchangeSchema = getExchangeSchema;
+exports.getFrameSchema = getFrameSchema;
 exports.getMode = getMode;
-exports.getOptimizer = getOptimizer;
+exports.getOptimizerSchema = getOptimizerSchema;
 exports.getOrderBook = getOrderBook;
-exports.getRisk = getRisk;
-exports.getSizing = getSizing;
-exports.getStrategy = getStrategy;
-exports.getWalker = getWalker;
+exports.getRiskSchema = getRiskSchema;
+exports.getSizingSchema = getSizingSchema;
+exports.getStrategySchema = getStrategySchema;
+exports.getSymbol = getSymbol;
+exports.getWalkerSchema = getWalkerSchema;
 exports.hasTradeContext = hasTradeContext;
 exports.lib = backtest;
-exports.listExchanges = listExchanges;
-exports.listFrames = listFrames;
-exports.listOptimizers = listOptimizers;
-exports.listRisks = listRisks;
-exports.listSizings = listSizings;
-exports.listStrategies = listStrategies;
-exports.listWalkers = listWalkers;
+exports.listExchangeSchema = listExchangeSchema;
+exports.listFrameSchema = listFrameSchema;
+exports.listOptimizerSchema = listOptimizerSchema;
+exports.listRiskSchema = listRiskSchema;
+exports.listSizingSchema = listSizingSchema;
+exports.listStrategySchema = listStrategySchema;
+exports.listWalkerSchema = listWalkerSchema;
+exports.listenActivePing = listenActivePing;
+exports.listenActivePingOnce = listenActivePingOnce;
 exports.listenBacktestProgress = listenBacktestProgress;
-exports.listenBreakeven = listenBreakeven;
-exports.listenBreakevenOnce = listenBreakevenOnce;
+exports.listenBreakevenAvailable = listenBreakevenAvailable;
+exports.listenBreakevenAvailableOnce = listenBreakevenAvailableOnce;
 exports.listenDoneBacktest = listenDoneBacktest;
 exports.listenDoneBacktestOnce = listenDoneBacktestOnce;
 exports.listenDoneLive = listenDoneLive;
@@ -31177,15 +31663,15 @@ exports.listenDoneWalkerOnce = listenDoneWalkerOnce;
 exports.listenError = listenError;
 exports.listenExit = listenExit;
 exports.listenOptimizerProgress = listenOptimizerProgress;
-exports.listenPartialLoss = listenPartialLoss;
-exports.listenPartialLossOnce = listenPartialLossOnce;
-exports.listenPartialProfit = listenPartialProfit;
-exports.listenPartialProfitOnce = listenPartialProfitOnce;
+exports.listenPartialLossAvailable = listenPartialLossAvailable;
+exports.listenPartialLossAvailableOnce = listenPartialLossAvailableOnce;
+exports.listenPartialProfitAvailable = listenPartialProfitAvailable;
+exports.listenPartialProfitAvailableOnce = listenPartialProfitAvailableOnce;
 exports.listenPerformance = listenPerformance;
-exports.listenPing = listenPing;
-exports.listenPingOnce = listenPingOnce;
 exports.listenRisk = listenRisk;
 exports.listenRiskOnce = listenRiskOnce;
+exports.listenSchedulePing = listenSchedulePing;
+exports.listenSchedulePingOnce = listenSchedulePingOnce;
 exports.listenSignal = listenSignal;
 exports.listenSignalBacktest = listenSignalBacktest;
 exports.listenSignalBacktestOnce = listenSignalBacktestOnce;
@@ -31197,22 +31683,18 @@ exports.listenWalker = listenWalker;
 exports.listenWalkerComplete = listenWalkerComplete;
 exports.listenWalkerOnce = listenWalkerOnce;
 exports.listenWalkerProgress = listenWalkerProgress;
-exports.overrideAction = overrideAction;
-exports.overrideExchange = overrideExchange;
-exports.overrideFrame = overrideFrame;
-exports.overrideOptimizer = overrideOptimizer;
-exports.overrideRisk = overrideRisk;
-exports.overrideSizing = overrideSizing;
-exports.overrideStrategy = overrideStrategy;
-exports.overrideWalker = overrideWalker;
-exports.partialLoss = partialLoss;
-exports.partialProfit = partialProfit;
+exports.overrideActionSchema = overrideActionSchema;
+exports.overrideExchangeSchema = overrideExchangeSchema;
+exports.overrideFrameSchema = overrideFrameSchema;
+exports.overrideOptimizerSchema = overrideOptimizerSchema;
+exports.overrideRiskSchema = overrideRiskSchema;
+exports.overrideSizingSchema = overrideSizingSchema;
+exports.overrideStrategySchema = overrideStrategySchema;
+exports.overrideWalkerSchema = overrideWalkerSchema;
 exports.roundTicks = roundTicks;
 exports.set = set;
 exports.setColumns = setColumns;
 exports.setConfig = setConfig;
 exports.setLogger = setLogger;
 exports.stop = stop;
-exports.trailingStop = trailingStop;
-exports.trailingTake = trailingTake;
 exports.validate = validate;