backtest-kit 14.0.0 → 14.1.0

package/build/index.mjs

@@ -748,6 +748,22 @@ const riskSubject = new Subject();
  * Allows users to track scheduled signal lifecycle and implement custom cancellation logic.
  */
 const schedulePingSubject = new Subject();
+/**
+ * Scheduled signal lifecycle emitter (creation and cancellation).
+ * Emits when a scheduled signal is created (action "scheduled") or cancelled before
+ * activation (action "cancelled": timeout / price_reject / user) during tick()/backtest().
+ *
+ * The scheduled -> active transition (activation) is intentionally NOT emitted here — that
+ * produces an "opened" signal on the regular signal emitters instead.
+ */
+const scheduleEventSubject = new Subject();
+/**
+ * Pending signal lifecycle emitter (open and close).
+ * Emits when a pending position is opened (action "opened": new signal / immediate / scheduled
+ * or user activation) or closed (action "closed" with closeReason take_profit / stop_loss /
+ * time_expired / closed) during tick()/backtest().
+ */
+const signalEventSubject = new Subject();
 /**
  * Active ping emitter for active pending signal monitoring events.
  * Emits every minute when an active pending signal is being monitored.
@@ -838,10 +854,12 @@ var emitters = /*#__PURE__*/Object.freeze({
     progressBacktestEmitter: progressBacktestEmitter,
     progressWalkerEmitter: progressWalkerEmitter,
     riskSubject: riskSubject,
+    scheduleEventSubject: scheduleEventSubject,
     schedulePingSubject: schedulePingSubject,
     shutdownEmitter: shutdownEmitter,
     signalBacktestEmitter: signalBacktestEmitter,
     signalEmitter: signalEmitter,
+    signalEventSubject: signalEventSubject,
     signalLiveEmitter: signalLiveEmitter,
     signalNotifySubject: signalNotifySubject,
     strategyCommitSubject: strategyCommitSubject,
@@ -1909,7 +1927,7 @@ class PersistStrategyInstance {
             const strategyData = await this._storage.readValue(PersistStrategyInstance.STORAGE_KEY);
             // JSON serializes Infinity as null, so an eternal-hold signal
             // (minuteEstimatedTime: Infinity) reads back as null — restore it.
-            for (const signal of [strategyData.closedSignal, strategyData.cancelledSignal, strategyData.activatedSignal]) {
+            for (const signal of [strategyData.closedSignal, strategyData.cancelledSignal, strategyData.activatedSignal, strategyData.takeProfitSignal, strategyData.stopLossSignal]) {
                 if (signal && signal.minuteEstimatedTime == null) {
                     signal.minuteEstimatedTime = Infinity;
                 }
@@ -7653,6 +7671,10 @@ const WAIT_FOR_INIT_FN$4 = async (self) => {
         self._closedSignal = strategyData.closedSignal;
         self._cancelledSignal = strategyData.cancelledSignal;
         self._activatedSignal = strategyData.activatedSignal;
+        // Deferred broker-confirmed TP/SL fills snapshot the pending signal and clear it (like
+        // _closedSignal), so they stand on their own and are restored unconditionally too.
+        self._takeProfitSignal = strategyData.takeProfitSignal;
+        self._stopLossSignal = strategyData.stopLossSignal;
     }
     // Restore pending signal
     const pendingSignal = await PersistSignalAdapter.readSignalData(self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName);
@@ -7733,6 +7755,8 @@ const PERSIST_STRATEGY_FN = async (self) => {
         closedSignal: self._closedSignal,
         cancelledSignal: self._cancelledSignal,
         activatedSignal: self._activatedSignal,
+        takeProfitSignal: self._takeProfitSignal,
+        stopLossSignal: self._stopLossSignal,
     }, self.params.symbol, self.params.strategyName, self.params.exchangeName);
 };
 const PARTIAL_PROFIT_FN = (self, signal, percentToClose, currentPrice, timestamp) => {
@@ -8266,6 +8290,7 @@ const CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN = async (self, scheduled, currentPrice)
         maxMinutes: GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES,
     });
     await self.setScheduledSignal(null);
+    await CALL_SCHEDULE_EVENT_FN$1(self, "cancelled", scheduled, currentPrice, currentTime, "timeout");
     await CALL_CANCEL_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, currentPrice, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "cancelled",
@@ -8322,6 +8347,7 @@ const CANCEL_SCHEDULED_SIGNAL_BY_STOPLOSS_FN = async (self, scheduled, currentPr
     });
     await self.setScheduledSignal(null);
     const currentTime = self.params.execution.context.when.getTime();
+    await CALL_SCHEDULE_EVENT_FN$1(self, "cancelled", scheduled, currentPrice, currentTime, "price_reject");
     await CALL_CANCEL_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, currentPrice, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "cancelled",
@@ -8415,6 +8441,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
     await self.setScheduledSignal(null);
     await self.setPendingSignal(activatedSignal, activatedSignal.priceOpen);
     await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, activatedSignal, activationTime, self.params.execution.context.backtest);
+    await CALL_SIGNAL_EVENT_FN(self, "opened", self._pendingSignal, self._pendingSignal.priceOpen, activationTime);
     await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, self._pendingSignal, self._pendingSignal.priceOpen, activationTime, self.params.execution.context.backtest);
     const result = {
         action: "opened",
@@ -8549,6 +8576,53 @@ const CALL_SCHEDULE_CALLBACKS_FN = trycatch(beginTime(async (self, symbol, signa
         errorEmitter.next(error);
     },
 });
+/**
+ * Emits a scheduled signal lifecycle event (creation / cancellation) to onScheduleEvent.
+ *
+ * Called when a scheduled signal is created (action "scheduled") or cancelled before activation
+ * (action "cancelled" with reason timeout / price_reject / user). The scheduled -> active
+ * transition is intentionally NOT emitted through this path.
+ *
+ * Unlike the CALL_*_CALLBACKS_FN helpers this does not run inside beginTime/runInContext: the
+ * timestamp is passed explicitly by the caller (tick when / candle timestamp) and forwarded to
+ * the connection-level emitter, mirroring how onSchedulePing carries its own timestamp.
+ */
+const CALL_SCHEDULE_EVENT_FN$1 = trycatch(async (self, action, signal, currentPrice, timestamp, reason) => {
+    await self.params.onScheduleEvent(action, self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, TO_PUBLIC_SIGNAL("scheduled", signal, currentPrice), currentPrice, self.params.execution.context.backtest, timestamp, reason);
+}, {
+    fallback: (error, self) => {
+        const message = "ClientStrategy CALL_SCHEDULE_EVENT_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.params.logger.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Emits a pending signal lifecycle event (open / close) to onSignalEvent.
+ *
+ * Called when a pending position is opened (action "opened") or closed (action "closed" with a
+ * closeReason). Like CALL_SCHEDULE_EVENT_FN it does not run inside beginTime/runInContext: the
+ * timestamp is passed explicitly by the caller (tick when / candle timestamp) and forwarded to
+ * the connection-level emitter.
+ */
+const CALL_SIGNAL_EVENT_FN = trycatch(async (self, action, signal, currentPrice, timestamp, closeReason) => {
+    await self.params.onSignalEvent(action, self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, TO_PUBLIC_SIGNAL("pending", signal, currentPrice), currentPrice, self.params.execution.context.backtest, timestamp, closeReason);
+}, {
+    fallback: (error, self) => {
+        const message = "ClientStrategy CALL_SIGNAL_EVENT_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.params.logger.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 const CALL_CANCEL_CALLBACKS_FN = trycatch(beginTime(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
         if (self.params.callbacks?.onCancel) {
@@ -8924,6 +8998,7 @@ const OPEN_NEW_SCHEDULED_SIGNAL_FN = async (self, signal) => {
         priceOpen: signal.priceOpen,
         currentPrice: currentPrice,
     });
+    await CALL_SCHEDULE_EVENT_FN$1(self, "scheduled", signal, currentPrice, currentTime);
     await CALL_SCHEDULE_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "scheduled",
@@ -8954,6 +9029,7 @@ const OPEN_NEW_PENDING_SIGNAL_FN = async (self, signal) => {
         return null;
     }
     await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, signal, currentTime, self.params.execution.context.backtest);
+    await CALL_SIGNAL_EVENT_FN(self, "opened", signal, signal.priceOpen, currentTime);
     await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, signal.priceOpen, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "opened",
@@ -9020,6 +9096,7 @@ const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason)
         priceClose: currentPrice,
         pnlPercentage: publicSignal.pnl.pnlPercentage,
     });
+    await CALL_SIGNAL_EVENT_FN(self, "closed", signal, currentPrice, currentTime, closeReason);
     await CALL_CLOSE_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
     // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
     await CALL_PARTIAL_CLEAR_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
@@ -9061,6 +9138,7 @@ const CLOSE_PENDING_SIGNAL_AS_CLOSED_FN = async (self, signal, currentPrice) =>
         priceClose: currentPrice,
         pnlPercentage: publicSignal.pnl.pnlPercentage,
     });
+    await CALL_SIGNAL_EVENT_FN(self, "closed", signal, currentPrice, currentTime, "closed");
     await CALL_CLOSE_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
     // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
     await CALL_PARTIAL_CLEAR_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
@@ -9231,6 +9309,7 @@ const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePr
     });
     await self.setScheduledSignal(null);
     const publicSignal = TO_PUBLIC_SIGNAL("scheduled", scheduled, averagePrice);
+    await CALL_SCHEDULE_EVENT_FN$1(self, "cancelled", scheduled, averagePrice, closeTimestamp, reason);
     if (reason === "user") {
         await CALL_COMMIT_FN(self, {
             action: "cancel-scheduled",
@@ -9343,6 +9422,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
     await self.setScheduledSignal(null);
     await self.setPendingSignal(activatedSignal, activatedSignal.priceOpen);
     await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, activatedSignal, activationTime, self.params.execution.context.backtest);
+    await CALL_SIGNAL_EVENT_FN(self, "opened", activatedSignal, activatedSignal.priceOpen, activationTime);
     await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, activatedSignal, activatedSignal.priceOpen, activationTime, self.params.execution.context.backtest);
     await CALL_BACKTEST_SCHEDULE_OPEN_FN(self, self.params.execution.context.symbol, activatedSignal, activationTime, self.params.execution.context.backtest);
     return true;
@@ -9373,6 +9453,7 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
     if (closeReason === "time_expired" && publicSignal.pnl.pnlPercentage < 0) {
         self.params.logger.warn(`ClientStrategy backtest: Signal closed with loss (time_expired), PNL: ${publicSignal.pnl.pnlPercentage.toFixed(2)}%`);
     }
+    await CALL_SIGNAL_EVENT_FN(self, "closed", signal, averagePrice, closeTimestamp, closeReason);
     await CALL_CLOSE_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
     // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
     await CALL_PARTIAL_CLEAR_FN(self, self.params.execution.context.symbol, signal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
@@ -9431,6 +9512,7 @@ const CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, closedSignal, aver
         signal: publicSignal,
         note: closedSignal.closeNote ?? closedSignal.note,
     });
+    await CALL_SIGNAL_EVENT_FN(self, "closed", closedSignal, averagePrice, closeTimestamp, "closed");
     await CALL_CLOSE_CALLBACKS_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
     await CALL_PARTIAL_CLEAR_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
     await CALL_BREAKEVEN_CLEAR_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
@@ -9453,6 +9535,79 @@ const CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, closedSignal, aver
     await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
     return result;
 };
+/**
+ * Closes a deferred broker-confirmed TP/SL fill (createTakeProfit / createStopLoss).
+ *
+ * The exchange and the strategy are parallel states: ClientStrategy evaluates TP/SL against VWAP,
+ * but the real order may fill on candle high/low. When the broker confirms such a fill out of
+ * context, the pending signal is snapshotted into _takeProfitSignal / _stopLossSignal and the next
+ * tick()/backtest() drains it here, closing with the matching closeReason at the effective TP/SL
+ * level (trailing override if set) — bypassing the VWAP completion check.
+ *
+ * Shared by live tick and backtest: the caller passes the close timestamp explicitly (execution
+ * context when in live, candle timestamp in backtest). Mirrors CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN
+ * (commit action "close-pending", carrying closeId/note) but with closeReason take_profit / stop_loss.
+ *
+ * Like the deferred close, the fill snapshot is already established by the broker, so it does NOT
+ * re-confirm via onSignalSync. _takeProfitSignal / _stopLossSignal is cleared and re-persisted by
+ * the caller after draining.
+ */
+const CLOSE_PENDING_SIGNAL_AS_FILL_FN = async (self, filledSignal, closeReason, closeTimestamp) => {
+    const closePrice = closeReason === "take_profit"
+        ? (filledSignal._trailingPriceTakeProfit ?? filledSignal.priceTakeProfit)
+        : (filledSignal._trailingPriceStopLoss ?? filledSignal.priceStopLoss);
+    const publicSignal = TO_PUBLIC_SIGNAL("pending", filledSignal, closePrice);
+    self.params.logger.info(`ClientStrategy signal ${closeReason} by broker-confirmed fill (createTakeProfit/createStopLoss)`, {
+        symbol: self.params.execution.context.symbol,
+        signalId: filledSignal.id,
+        closeReason,
+        priceClose: closePrice,
+        pnlPercentage: publicSignal.pnl.pnlPercentage,
+    });
+    await CALL_COMMIT_FN(self, {
+        action: "close-pending",
+        symbol: self.params.execution.context.symbol,
+        strategyName: self.params.strategyName,
+        exchangeName: self.params.exchangeName,
+        frameName: self.params.frameName,
+        signalId: filledSignal.id,
+        backtest: self.params.execution.context.backtest,
+        closeId: filledSignal.closeId,
+        timestamp: closeTimestamp,
+        totalEntries: filledSignal._entry?.length ?? 1,
+        totalPartials: filledSignal._partial?.length ?? 0,
+        originalPriceOpen: filledSignal.priceOpen,
+        pnl: publicSignal.pnl,
+        maxDrawdown: publicSignal.maxDrawdown,
+        peakProfit: publicSignal.peakProfit,
+        signal: publicSignal,
+        note: filledSignal.closeNote ?? filledSignal.note,
+    });
+    await CALL_SIGNAL_EVENT_FN(self, "closed", filledSignal, closePrice, closeTimestamp, closeReason);
+    await CALL_CLOSE_CALLBACKS_FN(self, self.params.execution.context.symbol, filledSignal, closePrice, closeTimestamp, self.params.execution.context.backtest);
+    // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
+    await CALL_PARTIAL_CLEAR_FN(self, self.params.execution.context.symbol, filledSignal, closePrice, closeTimestamp, self.params.execution.context.backtest);
+    // КРИТИЧНО: Очищаем состояние ClientBreakeven при закрытии позиции
+    await CALL_BREAKEVEN_CLEAR_FN(self, self.params.execution.context.symbol, filledSignal, closePrice, closeTimestamp, self.params.execution.context.backtest);
+    await CALL_RISK_REMOVE_SIGNAL_FN(self, self.params.execution.context.symbol, closeTimestamp, self.params.execution.context.backtest);
+    const result = {
+        action: "closed",
+        signal: publicSignal,
+        currentPrice: closePrice,
+        closeReason,
+        closeTimestamp,
+        pnl: publicSignal.pnl,
+        strategyName: self.params.method.context.strategyName,
+        exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
+        symbol: self.params.execution.context.symbol,
+        backtest: self.params.execution.context.backtest,
+        closeId: filledSignal.closeId,
+        createdAt: closeTimestamp,
+    };
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
+    return result;
+};
 const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles, frameEndTime) => {
     const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
     const maxTimeToWait = GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES * 60 * 1000;
@@ -9575,6 +9730,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles, fra
                 totalPartials: publicSignalForCommit.totalPartials,
                 note: activatedSignal.activateNote ?? publicSignalForCommit.note,
             });
+            await CALL_SIGNAL_EVENT_FN(self, "opened", pendingSignal, pendingSignal.priceOpen, candle.timestamp);
             await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, pendingSignal, pendingSignal.priceOpen, candle.timestamp, self.params.execution.context.backtest);
             await CALL_BACKTEST_SCHEDULE_OPEN_FN(self, self.params.execution.context.symbol, pendingSignal, candle.timestamp, self.params.execution.context.backtest);
             return { outcome: "activated", activationIndex: i };
@@ -9670,6 +9826,20 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles, frameEnd
             }
             continue;
         }
+        // КРИТИЧНО: Проверяем broker-confirmed TP fill через createTakeProfit() (напр. из onActivePing).
+        // Закрываем по эффективному уровню TP, минуя VWAP-проверку. Sync не пере-подтверждается.
+        if (self._takeProfitSignal) {
+            const filledSignal = self._takeProfitSignal;
+            self._takeProfitSignal = null;
+            return await CLOSE_PENDING_SIGNAL_AS_FILL_FN(self, filledSignal, "take_profit", currentCandleTimestamp);
+        }
+        // КРИТИЧНО: Проверяем broker-confirmed SL fill через createStopLoss() (напр. из onActivePing).
+        // Закрываем по эффективному уровню SL, минуя VWAP-проверку. Sync не пере-подтверждается.
+        if (self._stopLossSignal) {
+            const filledSignal = self._stopLossSignal;
+            self._stopLossSignal = null;
+            return await CLOSE_PENDING_SIGNAL_AS_FILL_FN(self, filledSignal, "stop_loss", currentCandleTimestamp);
+        }
         let shouldClose = false;
         let closeReason;
         // Check time expiration FIRST (КРИТИЧНО!)
@@ -9905,6 +10075,20 @@ class ClientStrategy {
         this._cancelledSignal = null;
         this._closedSignal = null;
         this._activatedSignal = null;
+        /**
+         * Deferred broker-confirmed take-profit fill (set via createTakeProfit). When non-null, the
+         * exchange reported the TP order was actually filled (e.g. by candle high/low) — the next
+         * tick()/backtest() drains it and closes the pending position with closeReason "take_profit"
+         * at the effective take-profit level, bypassing the VWAP-based TP check.
+         */
+        this._takeProfitSignal = null;
+        /**
+         * Deferred broker-confirmed stop-loss fill (set via createStopLoss). When non-null, the
+         * exchange reported the SL order was actually filled (e.g. by candle high/low) — the next
+         * tick()/backtest() drains it and closes the pending position with closeReason "stop_loss"
+         * at the effective stop-loss level, bypassing the VWAP-based SL check.
+         */
+        this._stopLossSignal = null;
         /**
          * User-supplied signal DTO to be consumed by the next GET_SIGNAL_FN tick instead of
          * params.getSignal. Set via createSignal. When non-null, params.getSignal is NOT called
@@ -9978,6 +10162,10 @@ class ClientStrategy {
         // - при null: сигнал закрыт по TP/SL/timeout, флаг больше не нужен
         // - при новом сигнале: флаг от предыдущего сигнала не должен влиять на новый
         this._closedSignal = null;
+        // КРИТИЧНО: Так же сбрасываем отложенные broker-confirmed TP/SL fills — закрытие позиции
+        // любым путём делает их неактуальными, а новая позиция не должна унаследовать чужой fill.
+        this._takeProfitSignal = null;
+        this._stopLossSignal = null;
         // ЗАЩИТА ИНВАРИАНТА: При установке нового pending сигнала очищаем scheduled
         // Не может быть одновременно pending И scheduled (взаимоисключающие состояния)
         // При null: scheduled может существовать (новый сигнал после закрытия позиции)
@@ -10871,6 +11059,7 @@ class ClientStrategy {
                 signal: publicSignal,
                 note: cancelledSignal.cancelNote ?? cancelledSignal.note,
             });
+            await CALL_SCHEDULE_EVENT_FN$1(this, "cancelled", cancelledSignal, currentPrice, currentTime, "user");
             // Call onCancel callback
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, currentTime, this.params.execution.context.backtest);
             const result = {
@@ -10931,6 +11120,7 @@ class ClientStrategy {
                 signal: publicSignal,
                 note: closedSignal.closeNote ?? closedSignal.note,
             });
+            await CALL_SIGNAL_EVENT_FN(this, "closed", closedSignal, currentPrice, currentTime, "closed");
             // Call onClose callback
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
             // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
@@ -10956,6 +11146,32 @@ class ClientStrategy {
             await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, result, currentTime, this.params.execution.context.backtest);
             return result;
         }
+        // Check if a broker-confirmed take-profit fill is awaiting (createTakeProfit) - close once.
+        // The exchange filled the TP order (e.g. by high/low); close bypassing the VWAP TP check.
+        if (this._takeProfitSignal) {
+            const filledSignal = this._takeProfitSignal;
+            this._takeProfitSignal = null; // Clear after draining
+            // Persist the cleared deferred state so the drained flag is not replayed on restart
+            await PERSIST_STRATEGY_FN(this);
+            this.params.logger.info("ClientStrategy tick: pending signal closed by broker-confirmed take-profit fill", {
+                symbol: this.params.execution.context.symbol,
+                signalId: filledSignal.id,
+            });
+            return await CLOSE_PENDING_SIGNAL_AS_FILL_FN(this, filledSignal, "take_profit", currentTime);
+        }
+        // Check if a broker-confirmed stop-loss fill is awaiting (createStopLoss) - close once.
+        // The exchange filled the SL order (e.g. by high/low); close bypassing the VWAP SL check.
+        if (this._stopLossSignal) {
+            const filledSignal = this._stopLossSignal;
+            this._stopLossSignal = null; // Clear after draining
+            // Persist the cleared deferred state so the drained flag is not replayed on restart
+            await PERSIST_STRATEGY_FN(this);
+            this.params.logger.info("ClientStrategy tick: pending signal closed by broker-confirmed stop-loss fill", {
+                symbol: this.params.execution.context.symbol,
+                signalId: filledSignal.id,
+            });
+            return await CLOSE_PENDING_SIGNAL_AS_FILL_FN(this, filledSignal, "stop_loss", currentTime);
+        }
         // Check if scheduled signal was activated - emit opened event once
         if (this._activatedSignal) {
             const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
@@ -11056,6 +11272,7 @@ class ClientStrategy {
                 totalPartials: publicSignalForCommit.totalPartials,
                 note: activatedSignal.activateNote ?? publicSignalForCommit.note,
             });
+            await CALL_SIGNAL_EVENT_FN(this, "opened", pendingSignal, currentPrice, currentTime);
             // Call onOpen callback
             await CALL_OPEN_CALLBACKS_FN(this, this.params.execution.context.symbol, pendingSignal, currentPrice, currentTime, this.params.execution.context.backtest);
             const result = {
@@ -11206,6 +11423,7 @@ class ClientStrategy {
                 signal: publicSignal,
                 note: cancelledSignal.cancelNote ?? cancelledSignal.note,
             });
+            await CALL_SCHEDULE_EVENT_FN$1(this, "cancelled", cancelledSignal, currentPrice, closeTimestamp, "user");
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             const cancelledResult = {
                 action: "cancelled",
@@ -11291,6 +11509,24 @@ class ClientStrategy {
             await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, closedResult, closeTimestamp, this.params.execution.context.backtest);
             return closedResult;
         }
+        // If a broker-confirmed take-profit fill is awaiting (createTakeProfit) - close once.
+        // The exchange filled the TP order (e.g. by high/low); close bypassing the VWAP TP check.
+        if (this._takeProfitSignal) {
+            this.params.logger.debug("ClientStrategy backtest: pending signal closed by broker-confirmed take-profit fill");
+            const filledSignal = this._takeProfitSignal;
+            this._takeProfitSignal = null; // Clear after draining
+            const closeTimestamp = this.params.execution.context.when.getTime();
+            return await CLOSE_PENDING_SIGNAL_AS_FILL_FN(this, filledSignal, "take_profit", closeTimestamp);
+        }
+        // If a broker-confirmed stop-loss fill is awaiting (createStopLoss) - close once.
+        // The exchange filled the SL order (e.g. by high/low); close bypassing the VWAP SL check.
+        if (this._stopLossSignal) {
+            this.params.logger.debug("ClientStrategy backtest: pending signal closed by broker-confirmed stop-loss fill");
+            const filledSignal = this._stopLossSignal;
+            this._stopLossSignal = null; // Clear after draining
+            const closeTimestamp = this.params.execution.context.when.getTime();
+            return await CLOSE_PENDING_SIGNAL_AS_FILL_FN(this, filledSignal, "stop_loss", closeTimestamp);
+        }
         if (!this._pendingSignal && !this._scheduledSignal) {
             throw new Error("ClientStrategy backtest: no pending or scheduled signal");
         }
@@ -11408,12 +11644,17 @@ class ClientStrategy {
             hasActivatedSignal: this._activatedSignal !== null,
             hasCancelledSignal: this._cancelledSignal !== null,
             hasClosedSignal: this._closedSignal !== null,
+            hasTakeProfitSignal: this._takeProfitSignal !== null,
+            hasStopLossSignal: this._stopLossSignal !== null,
         });
         this._isStopped = true;
         // Clear pending flags to start from clean state
         // NOTE: _isStopped blocks NEW position opening, but allows:
         // - cancelScheduled() / closePending() for graceful shutdown
         // - Monitoring existing _pendingSignal until TP/SL/timeout
+        // NOTE: _takeProfitSignal / _stopLossSignal are NOT cleared — a broker-confirmed fill
+        // reflects a real exchange close that must still drain to emit the closed event, the
+        // same way an existing _pendingSignal keeps being monitored until its natural close.
         this._activatedSignal = null;
         this._cancelledSignal = null;
         this._closedSignal = null;
@@ -11631,9 +11872,97 @@ class ClientStrategy {
         if (this._cancelledSignal) {
             throw new Error(`ClientStrategy createSignal: a scheduled cancel is awaiting for symbol=${symbol}`);
         }
+        if (this._takeProfitSignal) {
+            throw new Error(`ClientStrategy createSignal: a take-profit fill is awaiting for symbol=${symbol}`);
+        }
+        if (this._stopLossSignal) {
+            throw new Error(`ClientStrategy createSignal: a stop-loss fill is awaiting for symbol=${symbol}`);
+        }
         this._userSignal = dto;
         await PERSIST_STRATEGY_FN(this);
     }
+    /**
+     * Reports that the pending position's take-profit order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that does not wait for the VWAP-based TP check.
+     *
+     * The exchange and the strategy are parallel states: ClientStrategy evaluates TP/SL against
+     * VWAP, but the real order may close on high/low. This bridges that gap — the broker confirms
+     * the fill OUT of the async-hooks execution context, the current pending signal is snapshotted
+     * into _takeProfitSignal and cleared, and the next tick()/backtest() drains it, closing the
+     * position with closeReason "take_profit" at the effective take-profit level.
+     *
+     * No-op if no pending signal exists. Persisted (live mode only) so a crash before the next
+     * tick does not lose the deferred close.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param backtest - Whether running in backtest mode
+     * @param payload - Optional commit id/note attached to the close
+     * @returns Promise that resolves when the take-profit fill is queued
+     */
+    async createTakeProfit(symbol, backtest, payload) {
+        const closeId = payload.id;
+        this.params.logger.debug("ClientStrategy createTakeProfit", {
+            symbol,
+            hasPendingSignal: this._pendingSignal !== null,
+            closeId,
+        });
+        // Snapshot the pending signal for the next tick/backtest to close with reason "take_profit".
+        if (this._pendingSignal) {
+            this._takeProfitSignal = Object.assign({}, this._pendingSignal, {
+                closeId,
+                closeNote: payload.note,
+            });
+            this._pendingSignal = null;
+        }
+        if (backtest) {
+            // Drained in backtest() with correct candle timestamp; no live persistence.
+            return;
+        }
+        await PersistSignalAdapter.writeSignalData(this._pendingSignal, symbol, this.params.strategyName, this.params.exchangeName);
+        // Persist deferred _takeProfitSignal so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
+    }
+    /**
+     * Reports that the pending position's stop-loss order was actually filled on the exchange
+     * (e.g. by candle high/low), forcing a close that does not wait for the VWAP-based SL check.
+     *
+     * The exchange and the strategy are parallel states: ClientStrategy evaluates TP/SL against
+     * VWAP, but the real order may close on high/low. This bridges that gap — the broker confirms
+     * the fill OUT of the async-hooks execution context, the current pending signal is snapshotted
+     * into _stopLossSignal and cleared, and the next tick()/backtest() drains it, closing the
+     * position with closeReason "stop_loss" at the effective stop-loss level.
+     *
+     * No-op if no pending signal exists. Persisted (live mode only) so a crash before the next
+     * tick does not lose the deferred close.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param backtest - Whether running in backtest mode
+     * @param payload - Optional commit id/note attached to the close
+     * @returns Promise that resolves when the stop-loss fill is queued
+     */
+    async createStopLoss(symbol, backtest, payload) {
+        const closeId = payload.id;
+        this.params.logger.debug("ClientStrategy createStopLoss", {
+            symbol,
+            hasPendingSignal: this._pendingSignal !== null,
+            closeId,
+        });
+        // Snapshot the pending signal for the next tick/backtest to close with reason "stop_loss".
+        if (this._pendingSignal) {
+            this._stopLossSignal = Object.assign({}, this._pendingSignal, {
+                closeId,
+                closeNote: payload.note,
+            });
+            this._pendingSignal = null;
+        }
+        if (backtest) {
+            // Drained in backtest() with correct candle timestamp; no live persistence.
+            return;
+        }
+        await PersistSignalAdapter.writeSignalData(this._pendingSignal, symbol, this.params.strategyName, this.params.exchangeName);
+        // Persist deferred _stopLossSignal so a crash before the next tick does not lose it
+        await PERSIST_STRATEGY_FN(this);
+    }
     /**
      * Returns the deferred strategy-state snapshot exactly as it would be written to persist on
      * this iteration: the in-memory _userSignal, _commitQueue and deferred user-action flags,
@@ -11653,6 +11982,8 @@ class ClientStrategy {
             closedSignal: this._closedSignal,
             cancelledSignal: this._cancelledSignal,
             activatedSignal: this._activatedSignal,
+            takeProfitSignal: this._takeProfitSignal,
+            stopLossSignal: this._stopLossSignal,
         };
     }
     /**
@@ -12991,7 +13322,7 @@ const CREATE_SYNC_PENDING_FN = (self, strategyName, exchangeName, frameName, bac
         return true;
     }
     await syncPendingSubject.next(event);
-    await self.actionCoreService.orderPing(backtest, event, { strategyName, exchangeName, frameName });
+    await self.actionCoreService.orderCheck(backtest, event, { strategyName, exchangeName, frameName });
     return true;
 }, {
     fallback: (error) => {
@@ -13145,6 +13476,81 @@ const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => trycatch(async (symbol, strateg
     },
     defaultValue: null,
 });
+/**
+ * Creates a callback function for emitting scheduled signal lifecycle events to scheduleEventSubject.
+ *
+ * Called by ClientStrategy when a scheduled signal is created (action "scheduled") or cancelled
+ * before activation (action "cancelled": timeout / price_reject / user). The scheduled -> active
+ * transition is intentionally NOT reported here.
+ *
+ * @param self - Reference to StrategyConnectionService instance
+ * @returns Callback function for scheduled signal lifecycle events
+ */
+const CREATE_COMMIT_SCHEDULE_EVENT_FN = (self) => trycatch(async (action, symbol, strategyName, exchangeName, data, currentPrice, backtest, timestamp, reason) => {
+    const event = {
+        action,
+        symbol,
+        strategyName,
+        exchangeName,
+        frameName: data.frameName,
+        data,
+        reason,
+        currentPrice,
+        backtest,
+        timestamp,
+    };
+    await scheduleEventSubject.next(event);
+    await self.actionCoreService.scheduleEvent(backtest, event, { strategyName, exchangeName, frameName: data.frameName });
+}, {
+    fallback: (error) => {
+        const message = "StrategyConnectionService CREATE_COMMIT_SCHEDULE_EVENT_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+/**
+ * Creates a callback function for emitting pending signal lifecycle events to signalEventSubject.
+ *
+ * Called by ClientStrategy when a pending position is opened (action "opened") or closed
+ * (action "closed" with a closeReason).
+ *
+ * @param self - Reference to StrategyConnectionService instance
+ * @returns Callback function for pending signal lifecycle events
+ */
+const CREATE_COMMIT_SIGNAL_EVENT_FN = (self) => trycatch(async (action, symbol, strategyName, exchangeName, data, currentPrice, backtest, timestamp, closeReason) => {
+    const event = {
+        action,
+        symbol,
+        strategyName,
+        exchangeName,
+        frameName: data.frameName,
+        data,
+        closeReason,
+        currentPrice,
+        backtest,
+        timestamp,
+    };
+    await signalEventSubject.next(event);
+    await self.actionCoreService.pendingEvent(backtest, event, { strategyName, exchangeName, frameName: data.frameName });
+}, {
+    fallback: (error) => {
+        const message = "StrategyConnectionService CREATE_COMMIT_SIGNAL_EVENT_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
  * Creates a callback function for emitting idle ping events.
  *
@@ -13437,6 +13843,8 @@ class StrategyConnectionService {
                 callbacks,
                 onInit: CREATE_COMMIT_INIT_FN(this),
                 onSchedulePing: CREATE_COMMIT_SCHEDULE_PING_FN(this),
+                onScheduleEvent: CREATE_COMMIT_SCHEDULE_EVENT_FN(this),
+                onSignalEvent: CREATE_COMMIT_SIGNAL_EVENT_FN(this),
                 onActivePing: CREATE_COMMIT_ACTIVE_PING_FN(this),
                 onIdlePing: CREATE_COMMIT_IDLE_PING_FN(this),
                 onDispose: CREATE_COMMIT_DISPOSE_FN(this),
@@ -14456,6 +14864,50 @@ class StrategyConnectionService {
             const currentPrice = await this.priceMetaService.getCurrentPrice(symbol, context, backtest);
             await strategy.createSignal(symbol, currentPrice, dto);
         };
+        /**
+         * Reports that the pending position's take-profit order was actually filled on the exchange
+         * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+         *
+         * Delegates to ClientStrategy.createTakeProfit(). The close is deferred and emitted with
+         * closeReason "take_profit" on the next tick()/backtest(). Works out of the execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @param payload - Optional commit payload with id and note
+         * @returns Promise that resolves when the take-profit fill is queued
+         */
+        this.createTakeProfit = async (backtest, symbol, context, payload = {}) => {
+            this.loggerService.log("strategyConnectionService createTakeProfit", {
+                symbol,
+                context,
+                payload,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await strategy.createTakeProfit(symbol, backtest, payload);
+        };
+        /**
+         * Reports that the pending position's stop-loss order was actually filled on the exchange
+         * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+         *
+         * Delegates to ClientStrategy.createStopLoss(). The close is deferred and emitted with
+         * closeReason "stop_loss" on the next tick()/backtest(). Works out of the execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @param payload - Optional commit payload with id and note
+         * @returns Promise that resolves when the stop-loss fill is queued
+         */
+        this.createStopLoss = async (backtest, symbol, context, payload = {}) => {
+            this.loggerService.log("strategyConnectionService createStopLoss", {
+                symbol,
+                context,
+                payload,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await strategy.createStopLoss(symbol, backtest, payload);
+        };
         /**
          * Returns the in-memory deferred strategy-state snapshot for this iteration.
          *
@@ -16099,6 +16551,54 @@ const CALL_PING_IDLE_FN = trycatch(async (event, self) => {
     },
     defaultValue: null,
 });
+/**
+ * Wrapper to call scheduleEvent method with error capture.
+ *
+ * Unlike CALL_PING_SCHEDULED_FN there is no hasScheduledSignal guard: the "cancelled" action fires
+ * exactly while the scheduled signal is being removed, so guarding on its presence would suppress it.
+ */
+const CALL_SCHEDULE_EVENT_FN = trycatch(async (event, self) => {
+    if (!self._target.scheduleEvent) {
+        return;
+    }
+    return await self._target.scheduleEvent(event);
+}, {
+    fallback: (error) => {
+        const message = "ActionProxy.scheduleEvent thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        LOGGER_SERVICE$5.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+/**
+ * Wrapper to call pendingEvent method with error capture.
+ *
+ * Like CALL_SCHEDULE_EVENT_FN there is no hasPendingSignal guard: the "closed" action fires exactly
+ * while the pending signal is being removed, so guarding on its presence would suppress it.
+ */
+const CALL_PENDING_EVENT_FN = trycatch(async (event, self) => {
+    if (!self._target.pendingEvent) {
+        return;
+    }
+    return await self._target.pendingEvent(event);
+}, {
+    fallback: (error) => {
+        const message = "ActionProxy.pendingEvent thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        LOGGER_SERVICE$5.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
  * Wrapper to call pingActive method with error capture.
  */
@@ -16325,6 +16825,31 @@ class ActionProxy {
     async pingScheduled(event) {
         return await CALL_PING_SCHEDULED_FN(event, this);
     }
+    /**
+     * Handles scheduled signal lifecycle events with error capture.
+     *
+     * Wraps the user's scheduleEvent() method to catch and log any errors. Called once when a
+     * scheduled signal is created (action "scheduled") and once when it is cancelled before
+     * activation (action "cancelled").
+     *
+     * @param event - Scheduled lifecycle data (action discriminates created vs cancelled)
+     * @returns Promise resolving to user's scheduleEvent() result or null on error
+     */
+    async scheduleEvent(event) {
+        return await CALL_SCHEDULE_EVENT_FN(event, this);
+    }
+    /**
+     * Handles pending signal lifecycle events with error capture.
+     *
+     * Wraps the user's pendingEvent() method to catch and log any errors. Called once when a
+     * pending position is opened (action "opened") and once when it is closed (action "closed").
+     *
+     * @param event - Pending lifecycle data (action discriminates opened vs closed)
+     * @returns Promise resolving to user's pendingEvent() result or null on error
+     */
+    async pendingEvent(event) {
+        return await CALL_PENDING_EVENT_FN(event, this);
+    }
     /**
      * Handles active ping events with error capture.
      *
@@ -16383,14 +16908,14 @@ class ActionProxy {
      *
      * @param event - Pending-ping event with action "signal-ping"
      */
-    async orderPing(event) {
-        if (this._target.orderPing) {
-            console.error("Action::orderPing is unwanted cause exchange integration should be implemented in Broker.useBrokerAdapter as an infrastructure domain layer");
-            console.error("If you need to check whether the order is still open on the exchange, please use Broker.useBrokerAdapter with onOrderPing");
-            console.error("If Action::orderPing throws the framework will close the position with closeReason \"closed\"!");
+    async orderCheck(event) {
+        if (this._target.orderCheck) {
+            console.error("Action::orderCheck is unwanted cause exchange integration should be implemented in Broker.useBrokerAdapter as an infrastructure domain layer");
+            console.error("If you need to check whether the order is still open on the exchange, please use Broker.useBrokerAdapter with onOrderCheck");
+            console.error("If Action::orderCheck throws the framework will close the position with closeReason \"closed\"!");
             console.error("");
             console.error("You have been warned!");
-            await this._target.orderPing(event);
+            await this._target.orderCheck(event);
         }
     }
     /**
@@ -16552,6 +17077,40 @@ const CALL_PING_SCHEDULED_CALLBACK_FN = trycatch(async (self, event, strategyNam
         errorEmitter.next(error);
     },
 });
+/** Wrapper to call scheduled lifecycle (creation / cancellation) callback with error handling */
+const CALL_SCHEDULE_EVENT_CALLBACK_FN = trycatch(async (self, event, strategyName, frameName, backtest) => {
+    if (self.params.callbacks?.onScheduleEvent) {
+        await self.params.callbacks.onScheduleEvent(event, self.params.actionName, strategyName, frameName, backtest);
+    }
+}, {
+    fallback: (error, self) => {
+        const message = "ClientAction CALL_SCHEDULE_EVENT_CALLBACK_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.params.logger.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/** Wrapper to call pending lifecycle (open / close) callback with error handling */
+const CALL_PENDING_EVENT_CALLBACK_FN = trycatch(async (self, event, strategyName, frameName, backtest) => {
+    if (self.params.callbacks?.onPendingEvent) {
+        await self.params.callbacks.onPendingEvent(event, self.params.actionName, strategyName, frameName, backtest);
+    }
+}, {
+    fallback: (error, self) => {
+        const message = "ClientAction CALL_PENDING_EVENT_CALLBACK_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.params.logger.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /** Wrapper to call idle ping callback with error handling */
 const CALL_PING_IDLE_CALLBACK_FN = trycatch(async (self, event, strategyName, frameName, backtest) => {
     if (self.params.callbacks?.onPingIdle) {
@@ -16613,12 +17172,12 @@ const CALL_SIGNAL_SYNC_CALLBACK_FN = async (self, event, strategyName, frameName
     }
 };
 /**
- * Calls onOrderPing callback WITHOUT trycatch — exceptions must propagate
+ * Calls onOrderCheck callback WITHOUT trycatch — exceptions must propagate
  * up to CREATE_SYNC_PENDING_FN in StrategyConnectionService (which returns false on error).
  */
 const CALL_ORDER_PING_CALLBACK_FN = async (self, event, strategyName, frameName, isBacktest) => {
-    if (self.params.callbacks?.onOrderPing) {
-        await self.params.callbacks.onOrderPing(event, self.params.actionName, strategyName, frameName, isBacktest);
+    if (self.params.callbacks?.onOrderCheck) {
+        await self.params.callbacks.onOrderCheck(event, self.params.actionName, strategyName, frameName, isBacktest);
     }
 };
 /** Wrapper to call onInit callback with error handling */
@@ -16926,6 +17485,52 @@ class ClientAction {
         await CALL_PING_SCHEDULED_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
     }
     ;
+    /**
+     * Handles scheduled signal lifecycle events (creation / cancellation).
+     *
+     * Manual wiring — EVENT-BASED: users implement {@link IActionCallbacks.onScheduleEvent} (via `addActionSchema`)
+     * to drive the exchange (`commitActivateScheduled` / `commitCancelScheduled`); see that contract
+     * for the full guidance and example. This internal dispatch forwards to the handler/callback.
+     */
+    async scheduleEvent(event) {
+        this.params.logger.debug("ClientAction scheduleEvent", {
+            actionName: this.params.actionName,
+            strategyName: this.params.strategyName,
+            frameName: this.params.frameName,
+            action: event.action,
+        });
+        if (!this._handlerInstance) {
+            await this.waitForInit();
+        }
+        // Call handler method if defined
+        await this._handlerInstance?.scheduleEvent(event);
+        // Call callback if defined
+        await CALL_SCHEDULE_EVENT_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
+    }
+    ;
+    /**
+     * Handles pending signal lifecycle events (open / close).
+     *
+     * Manual wiring — EVENT-BASED: users implement {@link IActionCallbacks.onPendingEvent} (via `addActionSchema`) to
+     * drive the exchange; for per-tick fills use `onPingActive`. See that contract for the full
+     * guidance and example. This internal dispatch forwards to the handler/callback.
+     */
+    async pendingEvent(event) {
+        this.params.logger.debug("ClientAction pendingEvent", {
+            actionName: this.params.actionName,
+            strategyName: this.params.strategyName,
+            frameName: this.params.frameName,
+            action: event.action,
+        });
+        if (!this._handlerInstance) {
+            await this.waitForInit();
+        }
+        // Call handler method if defined
+        await this._handlerInstance?.pendingEvent(event);
+        // Call callback if defined
+        await CALL_PENDING_EVENT_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
+    }
+    ;
     /**
      * Handles active ping events during active pending signal monitoring.
      */
@@ -17003,8 +17608,8 @@ class ClientAction {
      * Gate for the pending-order ping (order still open on exchange?).
      * NOT wrapped in trycatch — exceptions propagate to CREATE_SYNC_PENDING_FN.
      */
-    async orderPing(event) {
-        this.params.logger.debug("ClientAction orderPing", {
+    async orderCheck(event) {
+        this.params.logger.debug("ClientAction orderCheck", {
             actionName: this.params.actionName,
             strategyName: this.params.strategyName,
             frameName: this.params.frameName,
@@ -17013,7 +17618,7 @@ class ClientAction {
             await this.waitForInit();
         }
         // Call handler method if defined — exceptions propagate
-        await this._handlerInstance?.orderPing(event);
+        await this._handlerInstance?.orderCheck(event);
         // Call callback if defined — exceptions propagate
         await CALL_ORDER_PING_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
     }
@@ -17218,6 +17823,36 @@ class ActionConnectionService {
             const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
             await action.pingScheduled(event);
         };
+        /**
+         * Routes a scheduled signal lifecycle event (creation / cancellation) to the ClientAction instance.
+         *
+         * @param event - Scheduled lifecycle event data (action discriminates created vs cancelled)
+         * @param backtest - Whether running in backtest mode
+         * @param context - Execution context with action name, strategy name, exchange name, frame name
+         */
+        this.scheduleEvent = async (event, backtest, context) => {
+            this.loggerService.log("actionConnectionService scheduleEvent", {
+                backtest,
+                context,
+            });
+            const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await action.scheduleEvent(event);
+        };
+        /**
+         * Routes a pending signal lifecycle event (open / close) to the ClientAction instance.
+         *
+         * @param event - Pending lifecycle event data (action discriminates opened vs closed)
+         * @param backtest - Whether running in backtest mode
+         * @param context - Execution context with action name, strategy name, exchange name, frame name
+         */
+        this.pendingEvent = async (event, backtest, context) => {
+            this.loggerService.log("actionConnectionService pendingEvent", {
+                backtest,
+                context,
+            });
+            const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await action.pendingEvent(event);
+        };
         /**
          * Routes active ping event to appropriate ClientAction instance.
          *
@@ -17281,20 +17916,20 @@ class ActionConnectionService {
             await action.signalSync(event);
         };
         /**
-         * Routes orderPing event to appropriate ClientAction instance.
+         * Routes orderCheck event to appropriate ClientAction instance.
          * NOT wrapped in trycatch — exceptions propagate to CREATE_SYNC_PENDING_FN.
          *
          * @param event - Pending-ping event with action "signal-ping"
          * @param backtest - Whether running in backtest mode
          * @param context - Execution context
          */
-        this.orderPing = async (event, backtest, context) => {
-            this.loggerService.log("actionConnectionService orderPing", {
+        this.orderCheck = async (event, backtest, context) => {
+            this.loggerService.log("actionConnectionService orderCheck", {
                 backtest,
                 context,
             });
             const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await action.orderPing(event);
+            await action.orderCheck(event);
         };
         /**
          * Disposes the ClientAction instance for the given action name.
@@ -18162,6 +18797,54 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.createSignal(backtest, symbol, dto, context);
         };
+        /**
+         * Reports that the pending position's take-profit order was actually filled on the exchange
+         * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+         *
+         * Validates the context, then delegates to StrategyConnectionService.createTakeProfit().
+         * The close is deferred and emitted with closeReason "take_profit" on the next tick/backtest.
+         * Does not require execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @param payload - Optional commit payload with id and note
+         * @returns Promise that resolves when the take-profit fill is queued
+         */
+        this.createTakeProfit = async (backtest, symbol, context, payload = {}) => {
+            this.loggerService.log("strategyCoreService createTakeProfit", {
+                symbol,
+                context,
+                backtest,
+                payload,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.createTakeProfit(backtest, symbol, context, payload);
+        };
+        /**
+         * Reports that the pending position's stop-loss order was actually filled on the exchange
+         * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+         *
+         * Validates the context, then delegates to StrategyConnectionService.createStopLoss().
+         * The close is deferred and emitted with closeReason "stop_loss" on the next tick/backtest.
+         * Does not require execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @param payload - Optional commit payload with id and note
+         * @returns Promise that resolves when the stop-loss fill is queued
+         */
+        this.createStopLoss = async (backtest, symbol, context, payload = {}) => {
+            this.loggerService.log("strategyCoreService createStopLoss", {
+                symbol,
+                context,
+                backtest,
+                payload,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.createStopLoss(backtest, symbol, context, payload);
+        };
         /**
          * Returns the in-memory deferred strategy-state snapshot for this iteration.
          *
@@ -19438,6 +20121,48 @@ class ActionCoreService {
                 await this.actionConnectionService.pingScheduled(event, backtest, { actionName, ...context });
             }
         };
+        /**
+         * Routes a scheduled signal lifecycle event (creation / cancellation) to all registered actions.
+         *
+         * Retrieves action list from strategy schema (IStrategySchema.actions) and invokes the
+         * scheduleEvent handler on each ClientAction instance sequentially. Called once on creation
+         * (action "scheduled") and once on cancellation before activation (action "cancelled").
+         *
+         * @param backtest - Whether running in backtest mode (true) or live mode (false)
+         * @param event - Scheduled lifecycle event data (action discriminates created vs cancelled)
+         * @param context - Strategy execution context with strategyName, exchangeName, frameName
+         */
+        this.scheduleEvent = async (backtest, event, context) => {
+            this.loggerService.log("actionCoreService scheduleEvent", {
+                context,
+            });
+            await this.validate(context);
+            const { actions = [] } = this.strategySchemaService.get(context.strategyName);
+            for (const actionName of actions) {
+                await this.actionConnectionService.scheduleEvent(event, backtest, { actionName, ...context });
+            }
+        };
+        /**
+         * Routes a pending signal lifecycle event (open / close) to all registered actions.
+         *
+         * Retrieves action list from strategy schema (IStrategySchema.actions) and invokes the
+         * pendingEvent handler on each ClientAction instance sequentially. Called once on open
+         * (action "opened") and once on close (action "closed").
+         *
+         * @param backtest - Whether running in backtest mode (true) or live mode (false)
+         * @param event - Pending lifecycle event data (action discriminates opened vs closed)
+         * @param context - Strategy execution context with strategyName, exchangeName, frameName
+         */
+        this.pendingEvent = async (backtest, event, context) => {
+            this.loggerService.log("actionCoreService pendingEvent", {
+                context,
+            });
+            await this.validate(context);
+            const { actions = [] } = this.strategySchemaService.get(context.strategyName);
+            for (const actionName of actions) {
+                await this.actionConnectionService.pendingEvent(event, backtest, { actionName, ...context });
+            }
+        };
         /**
          * Routes active ping event to all registered actions for the strategy.
          *
@@ -19528,14 +20253,14 @@ class ActionCoreService {
          * @param event - Pending-ping event with action "signal-ping"
          * @param context - Strategy execution context
          */
-        this.orderPing = async (backtest, event, context) => {
-            this.loggerService.log("actionCoreService orderPing", {
+        this.orderCheck = async (backtest, event, context) => {
+            this.loggerService.log("actionCoreService orderCheck", {
                 context,
             });
             await this.validate(context);
             const { actions = [] } = this.strategySchemaService.get(context.strategyName);
             for (const actionName of actions) {
-                await this.actionConnectionService.orderPing(event, backtest, { actionName, ...context });
+                await this.actionConnectionService.orderCheck(event, backtest, { actionName, ...context });
             }
         };
         /**
@@ -20003,6 +20728,8 @@ const VALID_METHOD_NAMES = [
     "partialLossAvailable",
     "pingScheduled",
     "pingActive",
+    "scheduleEvent",
+    "pendingEvent",
     "riskRejection",
     "dispose",
 ];
@@ -20013,7 +20740,7 @@ const VALID_METHOD_NAMES = [
  * method one of these produces a dedicated error redirecting to the Broker adapter instead of the
  * generic "invalid method" suggestion.
  */
-const DISCOURAGED_METHOD_NAMES = ["signalSync", "orderPing"];
+const DISCOURAGED_METHOD_NAMES = ["signalSync", "orderCheck"];
 /**
  * Builds the dedicated error message for a discouraged exchange-integration handler method.
  *
@@ -20025,7 +20752,7 @@ const DISCOURAGED_METHOD_MESSAGE = (actionName, methodName) => str.newline([
     `ActionSchema ${actionName} contains discouraged method "${methodName}". `,
     `Exchange integration must be implemented in Broker.useBrokerAdapter as the infrastructure domain layer, not in an action handler.`,
     typo.nbsp,
-    `Use Broker.useBrokerAdapter with onOrderPing (order still open?) and onSignalOpenCommit / onSignalCloseCommit (order fill) instead.`,
+    `Use Broker.useBrokerAdapter with onOrderCheck (order still open?) and onSignalOpenCommit / onSignalCloseCommit (order fill) instead.`,
     typo.nbsp,
     `If you want to keep this property name use one of these patterns: _${methodName} or #${methodName}`,
 ]);
@@ -42404,6 +43131,13 @@ const breakevenNewTakeProfitPrice = (priceTakeProfit, trailingPriceTakeProfit) =
 const BROKER_METHOD_NAME_COMMIT_SIGNAL_OPEN = "BrokerAdapter.commitSignalOpen";
 const BROKER_METHOD_NAME_COMMIT_SIGNAL_CLOSE = "BrokerAdapter.commitSignalClose";
 const BROKER_METHOD_NAME_COMMIT_SIGNAL_PENDING = "BrokerAdapter.commitSignalPending";
+const BROKER_METHOD_NAME_COMMIT_ACTIVE_PING = "BrokerAdapter.commitActivePing";
+const BROKER_METHOD_NAME_COMMIT_SCHEDULE_PING = "BrokerAdapter.commitSchedulePing";
+const BROKER_METHOD_NAME_COMMIT_IDLE_PING = "BrokerAdapter.commitIdlePing";
+const BROKER_METHOD_NAME_COMMIT_SCHEDULE_OPEN = "BrokerAdapter.commitScheduleOpen";
+const BROKER_METHOD_NAME_COMMIT_SCHEDULE_CANCELLED = "BrokerAdapter.commitScheduleCancelled";
+const BROKER_METHOD_NAME_COMMIT_PENDING_OPEN = "BrokerAdapter.commitPendingOpen";
+const BROKER_METHOD_NAME_COMMIT_PENDING_CLOSE = "BrokerAdapter.commitPendingClose";
 const BROKER_METHOD_NAME_COMMIT_PARTIAL_PROFIT = "BrokerAdapter.commitPartialProfit";
 const BROKER_METHOD_NAME_COMMIT_PARTIAL_LOSS = "BrokerAdapter.commitPartialLoss";
 const BROKER_METHOD_NAME_COMMIT_TRAILING_STOP = "BrokerAdapter.commitTrailingStop";
@@ -42417,7 +43151,14 @@ const BROKER_METHOD_NAME_CLEAR = "BrokerAdapter.clear";
 const BROKER_BASE_METHOD_NAME_WAIT_FOR_INIT = "BrokerBase.waitForInit";
 const BROKER_BASE_METHOD_NAME_ON_SIGNAL_OPEN = "BrokerBase.onSignalOpenCommit";
 const BROKER_BASE_METHOD_NAME_ON_SIGNAL_CLOSE = "BrokerBase.onSignalCloseCommit";
-const BROKER_BASE_METHOD_NAME_ON_SIGNAL_PENDING = "BrokerBase.onOrderPing";
+const BROKER_BASE_METHOD_NAME_ON_SIGNAL_PENDING = "BrokerBase.onOrderCheck";
+const BROKER_BASE_METHOD_NAME_ON_ACTIVE_PING = "BrokerBase.onSignalActivePing";
+const BROKER_BASE_METHOD_NAME_ON_SCHEDULE_PING = "BrokerBase.onSignalSchedulePing";
+const BROKER_BASE_METHOD_NAME_ON_IDLE_PING = "BrokerBase.onSignalIdlePing";
+const BROKER_BASE_METHOD_NAME_ON_SCHEDULE_OPEN = "BrokerBase.onSignalScheduleOpen";
+const BROKER_BASE_METHOD_NAME_ON_SCHEDULE_CANCELLED = "BrokerBase.onSignalScheduleCancelled";
+const BROKER_BASE_METHOD_NAME_ON_PENDING_OPEN = "BrokerBase.onSignalPendingOpen";
+const BROKER_BASE_METHOD_NAME_ON_PENDING_CLOSE = "BrokerBase.onSignalPendingClose";
 const BROKER_BASE_METHOD_NAME_ON_PARTIAL_PROFIT = "BrokerBase.onPartialProfitCommit";
 const BROKER_BASE_METHOD_NAME_ON_PARTIAL_LOSS = "BrokerBase.onPartialLossCommit";
 const BROKER_BASE_METHOD_NAME_ON_TRAILING_STOP = "BrokerBase.onTrailingStopCommit";
@@ -42469,7 +43210,7 @@ class BrokerProxy {
     /**
      * Forwards a pending-order ping to the underlying adapter.
      *
-     * If the adapter does not implement `onOrderPing`, the call is silently skipped
+     * If the adapter does not implement `onOrderCheck`, the call is silently skipped
      * (the order is assumed still open). When implemented, exceptions propagate — a throw means
      * the order was NOT FOUND by `payload.signalId` and the framework closes the position with
      * closeReason "closed". The adapter must throw ONLY on a confirmed "order not found by id"
@@ -42478,10 +43219,101 @@ class BrokerProxy {
      *
      * @param payload - Pending ping details: symbol, signalId, position, prices, pnl, context, backtest flag.
      */
-    async onOrderPing(payload) {
-        if (this._instance.onOrderPing) {
+    async onOrderCheck(payload) {
+        if (this._instance.onOrderCheck) {
+            await this.waitForInit();
+            await this._instance.onOrderCheck(payload);
+            return;
+        }
+    }
+    /**
+     * Forwards an active-ping event to the underlying adapter.
+     * Silently skipped when the adapter does not implement `onSignalActivePing`.
+     *
+     * @param payload - Active ping details: symbol, signalId, position, prices, pnl, context, backtest.
+     */
+    async onSignalActivePing(payload) {
+        if (this._instance.onSignalActivePing) {
+            await this.waitForInit();
+            await this._instance.onSignalActivePing(payload);
+            return;
+        }
+    }
+    /**
+     * Forwards a schedule-ping event to the underlying adapter.
+     * Silently skipped when the adapter does not implement `onSignalSchedulePing`.
+     *
+     * @param payload - Schedule ping details: symbol, signalId, position, prices, context, backtest.
+     */
+    async onSignalSchedulePing(payload) {
+        if (this._instance.onSignalSchedulePing) {
+            await this.waitForInit();
+            await this._instance.onSignalSchedulePing(payload);
+            return;
+        }
+    }
+    /**
+     * Forwards an idle-ping event to the underlying adapter.
+     * Silently skipped when the adapter does not implement `onSignalIdlePing`.
+     *
+     * @param payload - Idle ping details: symbol, currentPrice, context, backtest.
+     */
+    async onSignalIdlePing(payload) {
+        if (this._instance.onSignalIdlePing) {
+            await this.waitForInit();
+            await this._instance.onSignalIdlePing(payload);
+            return;
+        }
+    }
+    /**
+     * Forwards a scheduled-signal-open event to the underlying adapter.
+     * Silently skipped when the adapter does not implement `onSignalScheduleOpen`.
+     *
+     * @param payload - Scheduled open details: symbol, signalId, position, prices, context, backtest.
+     */
+    async onSignalScheduleOpen(payload) {
+        if (this._instance.onSignalScheduleOpen) {
+            await this.waitForInit();
+            await this._instance.onSignalScheduleOpen(payload);
+            return;
+        }
+    }
+    /**
+     * Forwards a scheduled-signal-cancelled event to the underlying adapter.
+     * Silently skipped when the adapter does not implement `onSignalScheduleCancelled`.
+     *
+     * @param payload - Scheduled cancel details: symbol, signalId, position, prices, reason, context, backtest.
+     */
+    async onSignalScheduleCancelled(payload) {
+        if (this._instance.onSignalScheduleCancelled) {
+            await this.waitForInit();
+            await this._instance.onSignalScheduleCancelled(payload);
+            return;
+        }
+    }
+    /**
+     * Forwards a pending-signal-open event to the underlying adapter.
+     * Silently skipped when the adapter does not implement `onSignalPendingOpen`.
+     *
+     * @param payload - Pending open details: symbol, signalId, position, prices, context, backtest.
+     */
+    async onSignalPendingOpen(payload) {
+        if (this._instance.onSignalPendingOpen) {
             await this.waitForInit();
-            await this._instance.onOrderPing(payload);
+            await this._instance.onSignalPendingOpen(payload);
+            return;
+        }
+    }
+    /**
+     * Forwards a pending-signal-close event to the underlying adapter.
+     * Silently skipped when the adapter does not implement `onSignalPendingClose`.
+     *
+     * @param payload - Pending close details: symbol, signalId, position, prices, closeReason, context, backtest.
+     */
+    async onSignalPendingClose(payload) {
+        if (this._instance.onSignalPendingClose) {
+            await this.waitForInit();
+            await this._instance.onSignalPendingClose(payload);
             return;
         }
     }
@@ -42737,7 +43569,178 @@ class BrokerAdapter {
             }
             const instance = this.getInstance();
             if (instance) {
-                await instance.onOrderPing(payload);
+                await instance.onOrderCheck(payload);
+            }
+        };
+        /**
+         * Forwards an active-ping to the registered broker adapter.
+         *
+         * Called automatically via activePingSubject when `enable()` is active, on every live tick while a
+         * pending signal is monitored. Skipped silently in backtest mode or when no adapter is registered.
+         * Purely informational — a throw does NOT close the position.
+         *
+         * @param payload - Active ping details: symbol, signalId, position, prices, pnl, context, backtest
+         */
+        this.commitActivePing = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_ACTIVE_PING, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onSignalActivePing(payload);
+            }
+        };
+        /**
+         * Forwards a schedule-ping to the registered broker adapter.
+         *
+         * Called automatically via schedulePingSubject when `enable()` is active, on every live tick while
+         * a scheduled signal is monitored. Skipped silently in backtest mode or when no adapter is
+         * registered. Purely informational.
+         *
+         * @param payload - Schedule ping details: symbol, signalId, position, prices, context, backtest
+         */
+        this.commitSchedulePing = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_SCHEDULE_PING, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onSignalSchedulePing(payload);
+            }
+        };
+        /**
+         * Forwards an idle-ping to the registered broker adapter.
+         *
+         * Called automatically via idlePingSubject when `enable()` is active, on every live tick while the
+         * strategy has no pending or scheduled signal. Skipped silently in backtest mode or when no adapter
+         * is registered. Purely informational.
+         *
+         * @param payload - Idle ping details: symbol, currentPrice, context, backtest
+         */
+        this.commitIdlePing = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_IDLE_PING, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onSignalIdlePing(payload);
+            }
+        };
+        /**
+         * Forwards a scheduled-signal-open to the registered broker adapter.
+         *
+         * Called automatically via scheduleEventSubject (action "scheduled") when a scheduled signal is
+         * created. Skipped silently in backtest mode or when no adapter is registered.
+         *
+         * @param payload - Scheduled open details: symbol, signalId, position, prices, context, backtest
+         */
+        this.commitScheduleOpen = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_SCHEDULE_OPEN, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onSignalScheduleOpen(payload);
+            }
+        };
+        /**
+         * Forwards a scheduled-signal-cancelled to the registered broker adapter.
+         *
+         * Called automatically via scheduleEventSubject (action "cancelled") when a scheduled signal is
+         * removed before activation. Skipped silently in backtest mode or when no adapter is registered.
+         *
+         * @param payload - Scheduled cancel details: symbol, signalId, position, prices, reason, context, backtest
+         */
+        this.commitScheduleCancelled = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_SCHEDULE_CANCELLED, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onSignalScheduleCancelled(payload);
+            }
+        };
+        /**
+         * Forwards a pending-signal-open to the registered broker adapter.
+         *
+         * Called automatically via signalEventSubject (action "opened") when a pending position is opened.
+         * Skipped silently in backtest mode or when no adapter is registered.
+         *
+         * @param payload - Pending open details: symbol, signalId, position, prices, context, backtest
+         */
+        this.commitPendingOpen = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_PENDING_OPEN, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onSignalPendingOpen(payload);
+            }
+        };
+        /**
+         * Forwards a pending-signal-close to the registered broker adapter.
+         *
+         * Called automatically via signalEventSubject (action "closed") when a pending position is closed.
+         * Skipped silently in backtest mode or when no adapter is registered.
+         *
+         * @param payload - Pending close details: symbol, signalId, position, prices, closeReason, context, backtest
+         */
+        this.commitPendingClose = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_PENDING_CLOSE, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onSignalPendingClose(payload);
             }
         };
         /**
@@ -43105,7 +44108,98 @@ class BrokerAdapter {
                     backtest: event.backtest,
                 });
             });
-            const disposeFn = compose(() => unSignalOpen(), () => unSignalClose(), () => unSignalPending());
+            const unActivePing = activePingSubject.subscribe(async (event) => {
+                await this.commitActivePing({
+                    symbol: event.symbol,
+                    signalId: event.data.id,
+                    position: event.data.position,
+                    currentPrice: event.currentPrice,
+                    priceOpen: event.data.priceOpen,
+                    priceTakeProfit: event.data.priceTakeProfit,
+                    priceStopLoss: event.data.priceStopLoss,
+                    pnl: event.data.pnl,
+                    context: {
+                        strategyName: event.strategyName,
+                        exchangeName: event.exchangeName,
+                        frameName: event.frameName,
+                    },
+                    backtest: event.backtest,
+                });
+            });
+            const unSchedulePing = schedulePingSubject.subscribe(async (event) => {
+                await this.commitSchedulePing({
+                    symbol: event.symbol,
+                    signalId: event.data.id,
+                    position: event.data.position,
+                    currentPrice: event.currentPrice,
+                    priceOpen: event.data.priceOpen,
+                    priceTakeProfit: event.data.priceTakeProfit,
+                    priceStopLoss: event.data.priceStopLoss,
+                    context: {
+                        strategyName: event.strategyName,
+                        exchangeName: event.exchangeName,
+                        frameName: event.frameName,
+                    },
+                    backtest: event.backtest,
+                });
+            });
+            const unIdlePing = idlePingSubject.subscribe(async (event) => {
+                await this.commitIdlePing({
+                    symbol: event.symbol,
+                    currentPrice: event.currentPrice,
+                    context: {
+                        strategyName: event.strategyName,
+                        exchangeName: event.exchangeName,
+                        frameName: event.frameName,
+                    },
+                    backtest: event.backtest,
+                });
+            });
+            const unScheduleEvent = scheduleEventSubject.subscribe(async (event) => {
+                const payload = {
+                    symbol: event.symbol,
+                    signalId: event.data.id,
+                    position: event.data.position,
+                    currentPrice: event.currentPrice,
+                    priceOpen: event.data.priceOpen,
+                    priceTakeProfit: event.data.priceTakeProfit,
+                    priceStopLoss: event.data.priceStopLoss,
+                    context: {
+                        strategyName: event.strategyName,
+                        exchangeName: event.exchangeName,
+                        frameName: event.frameName,
+                    },
+                    backtest: event.backtest,
+                };
+                if (event.action === "scheduled") {
+                    await this.commitScheduleOpen(payload);
+                    return;
+                }
+                await this.commitScheduleCancelled({ ...payload, reason: event.reason });
+            });
+            const unSignalEvent = signalEventSubject.subscribe(async (event) => {
+                const payload = {
+                    symbol: event.symbol,
+                    signalId: event.data.id,
+                    position: event.data.position,
+                    currentPrice: event.currentPrice,
+                    priceOpen: event.data.priceOpen,
+                    priceTakeProfit: event.data.priceTakeProfit,
+                    priceStopLoss: event.data.priceStopLoss,
+                    context: {
+                        strategyName: event.strategyName,
+                        exchangeName: event.exchangeName,
+                        frameName: event.frameName,
+                    },
+                    backtest: event.backtest,
+                };
+                if (event.action === "opened") {
+                    await this.commitPendingOpen(payload);
+                    return;
+                }
+                await this.commitPendingClose({ ...payload, closeReason: event.closeReason });
+            });
+            const disposeFn = compose(() => unSignalOpen(), () => unSignalClose(), () => unSignalPending(), () => unActivePing(), () => unSchedulePing(), () => unIdlePing(), () => unScheduleEvent(), () => unSignalEvent());
             return () => {
                 this.enable.clear();
                 disposeFn();
@@ -43251,24 +44345,32 @@ class BrokerBase {
         bt.loggerService.info(BROKER_BASE_METHOD_NAME_WAIT_FOR_INIT, {});
     }
     /**
-     * Called when a new position is opened (signal activated).
+     * Called when a position is being opened (signal activated).
      *
      * Triggered automatically via syncSubject when a scheduled signal's priceOpen is hit.
      * Use to place the actual entry order on the exchange.
      *
      * Default implementation: Logs signal-open event.
      *
+     * Manual wiring — EXCEPTION-BASED GATE: emitted BEFORE the framework mutates state, so a THROW here
+     * (e.g. limit order rejected) rolls back the open — the pending signal returns to idle and retries
+     * next tick; return normally to let it open. Live-only (backtest short-circuits). See
+     * {@link IBroker.onSignalOpenCommit} for the full semantics.
+     *
      * @param payload - Signal open details: symbol, cost, position, priceOpen, priceTakeProfit, priceStopLoss, context, backtest
      *
      * @example
      * ```typescript
      * async onSignalOpenCommit(payload: BrokerSignalOpenPayload) {
      *   super.onSignalOpenCommit(payload); // Keep parent logging
-     *   await this.exchange.placeMarketOrder({
+     *   const order = await this.exchange.placeMarketOrder({
      *     symbol: payload.symbol,
      *     side: payload.position === "long" ? "BUY" : "SELL",
      *     quantity: payload.cost / payload.priceOpen,
      *   });
+     *   if (!order.filled) {
+     *     throw new Error(`Entry not filled for ${payload.symbol}`); // -> roll back the open, retry next tick
+     *   }
      * }
      * ```
      */
@@ -43290,47 +44392,158 @@ class BrokerBase {
      * normally instead of throwing. A thrown network error would wrongly close an open position; only
      * a confirmed "order not found by id" response is a valid reason to throw.
      *
-     * @param payload - Pending ping details: symbol, signalId, position, prices, pnl, context, backtest
+     * Manual wiring — EXCEPTION-BASED VARIANT: the throw-driven alternative to the imperative
+     * commit-function wiring in `onSignalActivePing`. See {@link IBroker.onOrderCheck} for the full
+     * comparison and example.
      *
-     * @example
-     * ```typescript
-     * async onOrderPing(payload: BrokerSignalPendingPayload) {
-     *   super.onOrderPing(payload); // Keep parent logging
-     *   let order: Order | null;
-     *   try {
-     *     order = await this.exchange.getOrderById(payload.signalId);
-     *   } catch (networkError) {
-     *     // Transient/network error — swallow and keep the position open, retry next tick
-     *     return;
-     *   }
-     *   if (!order) {
-     *     // Confirmed not found by id — close the position
-     *     throw new Error(`Order ${payload.signalId} not found on the exchange`);
-     *   }
-     * }
-     * ```
+     * @param payload - Pending ping details: symbol, signalId, position, prices, pnl, context, backtest
      */
-    async onOrderPing(payload) {
+    async onOrderCheck(payload) {
         bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_SIGNAL_PENDING, {
             symbol: payload.symbol,
             context: payload.context,
         });
     }
     /**
-     * Called when a position is fully closed (SL/TP hit or manual close).
+     * Called on every live tick while a pending (open) signal is monitored.
+     *
+     * Purely informational mirror of the active-ping lifecycle — unlike `onOrderCheck`, a throw here
+     * does NOT close the position. Override to mirror live monitoring state into your own systems.
+     * The default implementation logs.
+     *
+     * Manual wiring — EVENT-BASED: this is the primary per-tick hook to drive an open position from real exchange
+     * state (`commitCreateTakeProfit` / `commitCreateStopLoss` / `commitClosePending`). See the
+     * {@link IBroker.onSignalActivePing} contract docs for the full guidance and example.
+     *
+     * @param payload - Active ping details: symbol, signalId, position, prices, pnl, context, backtest
+     */
+    async onSignalActivePing(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_ACTIVE_PING, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+    /**
+     * Called on every live tick while a scheduled signal is monitored (waiting for priceOpen).
+     *
+     * Purely informational. Override to mirror scheduled-monitoring state. The default logs.
+     *
+     * Manual wiring — EVENT-BASED: per-tick hook to drive a scheduled (resting) order from real exchange state
+     * (`commitActivateScheduled` / `commitCancelScheduled`). See {@link IBroker.onSignalSchedulePing}
+     * for full guidance and example.
+     *
+     * @param payload - Schedule ping details: symbol, signalId, position, prices, context, backtest
+     */
+    async onSignalSchedulePing(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_SCHEDULE_PING, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+    /**
+     * Called on every live tick while the strategy is idle (no pending or scheduled signal).
+     *
+     * Purely informational. Override to track idle heartbeats. The default logs.
+     *
+     * @param payload - Idle ping details: symbol, currentPrice, context, backtest
+     */
+    async onSignalIdlePing(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_IDLE_PING, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+    /**
+     * Called when a new scheduled signal is created and starts waiting for priceOpen activation.
+     *
+     * The scheduled -> active transition is reported via `onSignalOpenCommit`, not here. Override to
+     * place a resting/limit order on the exchange. The default logs.
+     *
+     * Manual wiring — EVENT-BASED: fires ONCE at creation — place the real resting order (tag it with
+     * `payload.signalId`) and optionally `commitActivateScheduled` / `commitCancelScheduled`. See
+     * {@link IBroker.onSignalScheduleOpen} for full guidance and example.
+     *
+     * @param payload - Scheduled open details: symbol, signalId, position, prices, context, backtest
+     */
+    async onSignalScheduleOpen(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_SCHEDULE_OPEN, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+    /**
+     * Called when a scheduled signal is cancelled before activation (timeout / price_reject / user).
+     *
+     * Override to cancel the resting/limit order on the exchange. The default logs.
+     *
+     * Manual wiring — EVENT-BASED (outbound): the strategy already dropped the scheduled signal — cancel the matching
+     * exchange order by `payload.signalId`. See {@link IBroker.onSignalScheduleCancelled}.
+     *
+     * @param payload - Scheduled cancel details: symbol, signalId, position, prices, reason, context, backtest
+     */
+    async onSignalScheduleCancelled(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_SCHEDULE_CANCELLED, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+    /**
+     * Called when a pending position is opened (new signal / immediate / scheduled or user activation).
+     *
+     * Informational lifecycle hook. Override to mirror the open into your own systems. The default logs.
+     *
+     * Manual wiring — EVENT-BASED: fires ONCE at open — place entry + protective TP/SL orders (tag with
+     * `payload.signalId`), then drive per-tick from `onSignalActivePing`. See
+     * {@link IBroker.onSignalPendingOpen}.
+     *
+     * @param payload - Pending open details: symbol, signalId, position, prices, context, backtest
+     */
+    async onSignalPendingOpen(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_PENDING_OPEN, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+    /**
+     * Called when a pending position is closed (take_profit / stop_loss / time_expired / closed).
+     *
+     * Informational lifecycle hook. Override to mirror the close into your own systems. The default logs.
+     *
+     * Manual wiring — EVENT-BASED (outbound): the strategy already removed the pending signal — flatten the real
+     * position and cancel leftover TP/SL orders by `payload.signalId`. See
+     * {@link IBroker.onSignalPendingClose}.
+     *
+     * @param payload - Pending close details: symbol, signalId, position, prices, closeReason, context, backtest
+     */
+    async onSignalPendingClose(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_PENDING_CLOSE, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+    /**
+     * Called when a position is being closed (SL/TP hit or manual close).
      *
      * Triggered automatically via syncSubject when a pending signal is closed.
      * Use to place the exit order and record final PnL.
      *
      * Default implementation: Logs signal-close event.
      *
+     * Manual wiring — EXCEPTION-BASED GATE: emitted BEFORE the framework mutates state, so a THROW here
+     * (e.g. exit order failed) SKIPS the close — the position stays open and the close retries next
+     * tick; return normally to let it close. Live-only (backtest short-circuits). See
+     * {@link IBroker.onSignalCloseCommit} for the full semantics.
+     *
      * @param payload - Signal close details: symbol, cost, position, currentPrice, pnl, totalEntries, totalPartials, context, backtest
      *
      * @example
      * ```typescript
      * async onSignalCloseCommit(payload: BrokerSignalClosePayload) {
      *   super.onSignalCloseCommit(payload); // Keep parent logging
-     *   await this.exchange.closePosition(payload.symbol);
+     *   const ok = await this.exchange.closePosition(payload.symbol);
+     *   if (!ok) {
+     *     throw new Error(`Exit not filled for ${payload.symbol}`); // -> keep position open, retry next tick
+     *   }
      *   await this.db.recordTrade({ symbol: payload.symbol, pnl: payload.pnl });
      * }
      * ```
@@ -43586,6 +44799,8 @@ const HAS_NO_PENDING_SIGNAL_METHOD_NAME = "strategy.hasNoPendingSignal";
 const HAS_NO_SCHEDULED_SIGNAL_METHOD_NAME = "strategy.hasNoScheduledSignal";
 const COMMIT_SIGNAL_NOTIFY_METHOD_NAME = "strategy.commitSignalNotify";
 const COMMIT_CREATE_SIGNAL_METHOD_NAME = "strategy.commitCreateSignal";
+const COMMIT_CREATE_TAKE_PROFIT_METHOD_NAME = "strategy.commitCreateTakeProfit";
+const COMMIT_CREATE_STOP_LOSS_METHOD_NAME = "strategy.commitCreateStopLoss";
 const GET_STRATEGY_STATUS_METHOD_NAME = "strategy.getStrategyStatus";
 /**
  * Cancels the scheduled signal without stopping the strategy.
@@ -45695,6 +46910,74 @@ async function commitCreateSignal(symbol, dto) {
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     await bt.strategyCoreService.createSignal(isBacktest, symbol, dto, { exchangeName, frameName, strategyName });
 }
+/**
+ * Reports that the pending position's take-profit order was actually filled on the exchange
+ * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+ *
+ * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+ * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+ * "take_profit" on the next tick. No-op if no pending signal exists.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param payload - Optional commit payload with id and note
+ * @returns Promise that resolves when the take-profit fill is queued
+ *
+ * @example
+ * ```typescript
+ * import { commitCreateTakeProfit } from "backtest-kit";
+ *
+ * // Report TP fill confirmed on the exchange
+ * await commitCreateTakeProfit("BTCUSDT", { id: "tp-fill-001" });
+ * ```
+ */
+async function commitCreateTakeProfit(symbol, payload = {}) {
+    bt.loggerService.info(COMMIT_CREATE_TAKE_PROFIT_METHOD_NAME, { symbol, payload });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitCreateTakeProfit requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitCreateTakeProfit requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    await bt.strategyCoreService.createTakeProfit(isBacktest, symbol, { exchangeName, frameName, strategyName }, payload);
+}
+/**
+ * Reports that the pending position's stop-loss order was actually filled on the exchange
+ * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+ *
+ * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+ * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+ * "stop_loss" on the next tick. No-op if no pending signal exists.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param payload - Optional commit payload with id and note
+ * @returns Promise that resolves when the stop-loss fill is queued
+ *
+ * @example
+ * ```typescript
+ * import { commitCreateStopLoss } from "backtest-kit";
+ *
+ * // Report SL fill confirmed on the exchange
+ * await commitCreateStopLoss("BTCUSDT", { id: "sl-fill-001" });
+ * ```
+ */
+async function commitCreateStopLoss(symbol, payload = {}) {
+    bt.loggerService.info(COMMIT_CREATE_STOP_LOSS_METHOD_NAME, { symbol, payload });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitCreateStopLoss requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitCreateStopLoss requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    await bt.strategyCoreService.createStopLoss(isBacktest, symbol, { exchangeName, frameName, strategyName }, payload);
+}
 /**
  * Returns the in-memory deferred strategy-state snapshot for the current iteration: the queued
  * createSignal, commit queue and deferred user-action flags, plus the current pending signal id.
@@ -45797,6 +47080,10 @@ const LISTEN_RISK_METHOD_NAME = "event.listenRisk";
 const LISTEN_RISK_ONCE_METHOD_NAME = "event.listenRiskOnce";
 const LISTEN_SCHEDULE_PING_METHOD_NAME = "event.listenSchedulePing";
 const LISTEN_SCHEDULE_PING_ONCE_METHOD_NAME = "event.listenSchedulePingOnce";
+const LISTEN_SCHEDULE_EVENT_METHOD_NAME = "event.listenScheduleEvent";
+const LISTEN_SCHEDULE_EVENT_ONCE_METHOD_NAME = "event.listenScheduleEventOnce";
+const LISTEN_SIGNAL_EVENT_METHOD_NAME = "event.listenSignalEvent";
+const LISTEN_SIGNAL_EVENT_ONCE_METHOD_NAME = "event.listenSignalEventOnce";
 const LISTEN_ACTIVE_PING_METHOD_NAME = "event.listenActivePing";
 const LISTEN_ACTIVE_PING_ONCE_METHOD_NAME = "event.listenActivePingOnce";
 const LISTEN_IDLE_PING_METHOD_NAME = "event.listenIdlePing";
@@ -46899,6 +48186,137 @@ function listenSchedulePingOnce(filterFn, fn) {
     };
     return disposeFn = listenSchedulePing(wrappedFn);
 }
+/**
+ * Subscribes to scheduled signal lifecycle events (creation and cancellation) with queued async processing.
+ *
+ * Emitted when a scheduled signal is created (action "scheduled") or cancelled before activation
+ * (action "cancelled" with reason "timeout" / "price_reject" / "user"), in both live and backtest.
+ *
+ * IMPORTANT: The scheduled -> active transition (activation) is NOT reported here. Activation
+ * produces an "opened" event on the regular signal emitters (listenSignal) instead.
+ *
+ * Events are processed sequentially in order received, even if callback is async.
+ *
+ * @param fn - Callback function to handle scheduled lifecycle events
+ * @returns Unsubscribe function to stop listening
+ *
+ * @example
+ * ```typescript
+ * import { listenScheduleEvent } from "./function/event";
+ *
+ * const unsubscribe = listenScheduleEvent((event) => {
+ *   if (event.action === "scheduled") {
+ *     console.log(`Scheduled ${event.symbol} @ ${event.data.priceOpen}`);
+ *   } else {
+ *     console.log(`Cancelled ${event.symbol} (reason: ${event.reason})`);
+ *   }
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenScheduleEvent(fn) {
+    bt.loggerService.log(LISTEN_SCHEDULE_EVENT_METHOD_NAME);
+    return scheduleEventSubject.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered scheduled lifecycle events with one-time execution.
+ *
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for a specific scheduled creation
+ * or cancellation.
+ *
+ * @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 { listenScheduleEventOnce } from "./function/event";
+ *
+ * // Wait for the first cancellation on BTCUSDT
+ * listenScheduleEventOnce(
+ *   (event) => event.symbol === "BTCUSDT" && event.action === "cancelled",
+ *   (event) => console.log("BTCUSDT scheduled cancelled:", event.reason)
+ * );
+ * ```
+ */
+function listenScheduleEventOnce(filterFn, fn) {
+    bt.loggerService.log(LISTEN_SCHEDULE_EVENT_ONCE_METHOD_NAME);
+    let disposeFn;
+    const wrappedFn = async (event) => {
+        if (filterFn(event)) {
+            await fn(event);
+            disposeFn && disposeFn();
+        }
+    };
+    return disposeFn = listenScheduleEvent(wrappedFn);
+}
+/**
+ * Subscribes to pending signal lifecycle events (open and close) with queued async processing.
+ *
+ * Emitted when a pending position is opened (action "opened": new signal / immediate / scheduled
+ * or user activation) or closed (action "closed" with closeReason "take_profit" / "stop_loss" /
+ * "time_expired" / "closed"), in both live and backtest.
+ *
+ * Events are processed sequentially in order received, even if callback is async.
+ *
+ * @param fn - Callback function to handle pending lifecycle events
+ * @returns Unsubscribe function to stop listening
+ *
+ * @example
+ * ```typescript
+ * import { listenSignalEvent } from "./function/event";
+ *
+ * const unsubscribe = listenSignalEvent((event) => {
+ *   if (event.action === "opened") {
+ *     console.log(`Opened ${event.symbol} @ ${event.data.priceOpen}`);
+ *   } else {
+ *     console.log(`Closed ${event.symbol} (reason: ${event.closeReason})`);
+ *   }
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenSignalEvent(fn) {
+    bt.loggerService.log(LISTEN_SIGNAL_EVENT_METHOD_NAME);
+    return signalEventSubject.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered pending lifecycle events with one-time execution.
+ *
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for a specific open or close.
+ *
+ * @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 { listenSignalEventOnce } from "./function/event";
+ *
+ * // Wait for the first close on BTCUSDT
+ * listenSignalEventOnce(
+ *   (event) => event.symbol === "BTCUSDT" && event.action === "closed",
+ *   (event) => console.log("BTCUSDT closed:", event.closeReason)
+ * );
+ * ```
+ */
+function listenSignalEventOnce(filterFn, fn) {
+    bt.loggerService.log(LISTEN_SIGNAL_EVENT_ONCE_METHOD_NAME);
+    let disposeFn;
+    const wrappedFn = async (event) => {
+        if (filterFn(event)) {
+            await fn(event);
+            disposeFn && disposeFn();
+        }
+    };
+    return disposeFn = listenSignalEvent(wrappedFn);
+}
 /**
  * Subscribes to active ping events with queued async processing.
  *
@@ -47396,6 +48814,8 @@ const BACKTEST_METHOD_NAME_BREAKEVEN = "Backtest.commitBreakeven";
 const BACKTEST_METHOD_NAME_CANCEL_SCHEDULED = "Backtest.commitCancelScheduled";
 const BACKTEST_METHOD_NAME_CLOSE_PENDING = "Backtest.commitClosePending";
 const BACKTEST_METHOD_NAME_COMMIT_CREATE_SIGNAL = "Backtest.commitCreateSignal";
+const BACKTEST_METHOD_NAME_COMMIT_CREATE_TAKE_PROFIT = "Backtest.commitCreateTakeProfit";
+const BACKTEST_METHOD_NAME_COMMIT_CREATE_STOP_LOSS = "Backtest.commitCreateStopLoss";
 const BACKTEST_METHOD_NAME_GET_STRATEGY_STATUS = "Backtest.getStrategyStatus";
 const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.commitPartialProfit";
 const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.commitPartialLoss";
@@ -49132,6 +50552,90 @@ class BacktestUtils {
             }
             await bt.strategyCoreService.createSignal(true, symbol, dto, context);
         };
+        /**
+         * Reports that the pending position's take-profit order was actually filled on the exchange
+         * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+         *
+         * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+         * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+         * "take_profit" on the next backtest tick. No-op if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @param payload - Optional commit payload with id and note
+         * @returns Promise that resolves when the take-profit fill is queued
+         *
+         * @example
+         * ```typescript
+         * // Report TP fill confirmed on the exchange
+         * await Backtest.commitCreateTakeProfit("BTCUSDT", {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy",
+         *   frameName: "1m"
+         * }, { id: "tp-fill-001" });
+         * ```
+         */
+        this.commitCreateTakeProfit = async (symbol, context, payload = {}) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_COMMIT_CREATE_TAKE_PROFIT, {
+                symbol,
+                context,
+                payload,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_COMMIT_CREATE_TAKE_PROFIT);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_COMMIT_CREATE_TAKE_PROFIT);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_COMMIT_CREATE_TAKE_PROFIT);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_COMMIT_CREATE_TAKE_PROFIT));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_COMMIT_CREATE_TAKE_PROFIT));
+            }
+            await bt.strategyCoreService.createTakeProfit(true, symbol, context, payload);
+        };
+        /**
+         * Reports that the pending position's stop-loss order was actually filled on the exchange
+         * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+         *
+         * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+         * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+         * "stop_loss" on the next backtest tick. No-op if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @param payload - Optional commit payload with id and note
+         * @returns Promise that resolves when the stop-loss fill is queued
+         *
+         * @example
+         * ```typescript
+         * // Report SL fill confirmed on the exchange
+         * await Backtest.commitCreateStopLoss("BTCUSDT", {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy",
+         *   frameName: "1m"
+         * }, { id: "sl-fill-001" });
+         * ```
+         */
+        this.commitCreateStopLoss = async (symbol, context, payload = {}) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_COMMIT_CREATE_STOP_LOSS, {
+                symbol,
+                context,
+                payload,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_COMMIT_CREATE_STOP_LOSS);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_COMMIT_CREATE_STOP_LOSS);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_COMMIT_CREATE_STOP_LOSS);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_COMMIT_CREATE_STOP_LOSS));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_COMMIT_CREATE_STOP_LOSS));
+            }
+            await bt.strategyCoreService.createStopLoss(true, symbol, context, payload);
+        };
         /**
          * Returns the in-memory deferred strategy-state snapshot for the current backtest iteration.
          *
@@ -50117,6 +51621,8 @@ const LIVE_METHOD_NAME_BREAKEVEN = "Live.commitBreakeven";
 const LIVE_METHOD_NAME_CANCEL_SCHEDULED = "Live.cancelScheduled";
 const LIVE_METHOD_NAME_CLOSE_PENDING = "Live.closePending";
 const LIVE_METHOD_NAME_COMMIT_CREATE_SIGNAL = "Live.commitCreateSignal";
+const LIVE_METHOD_NAME_COMMIT_CREATE_TAKE_PROFIT = "Live.commitCreateTakeProfit";
+const LIVE_METHOD_NAME_COMMIT_CREATE_STOP_LOSS = "Live.commitCreateStopLoss";
 const LIVE_METHOD_NAME_GET_STRATEGY_STATUS = "Live.getStrategyStatus";
 const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.commitPartialProfit";
 const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.commitPartialLoss";
@@ -52030,6 +53536,78 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Reports that the pending position's take-profit order was actually filled on the exchange
+         * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based TP check.
+         *
+         * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+         * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+         * "take_profit" on the next live tick. No-op if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @param payload - Optional commit payload with id and note
+         * @returns Promise that resolves when the take-profit fill is queued
+         */
+        this.commitCreateTakeProfit = async (symbol, context, payload = {}) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_COMMIT_CREATE_TAKE_PROFIT, {
+                symbol,
+                context,
+                payload,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_COMMIT_CREATE_TAKE_PROFIT);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_COMMIT_CREATE_TAKE_PROFIT);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_COMMIT_CREATE_TAKE_PROFIT);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_COMMIT_CREATE_TAKE_PROFIT));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_COMMIT_CREATE_TAKE_PROFIT));
+            }
+            await bt.strategyCoreService.createTakeProfit(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }, payload);
+        };
+        /**
+         * Reports that the pending position's stop-loss order was actually filled on the exchange
+         * (e.g. by candle high/low), forcing a close that bypasses the VWAP-based SL check.
+         *
+         * The exchange and the strategy are parallel states: the framework evaluates TP/SL against VWAP,
+         * but the real order may fill on high/low. The close is deferred and emitted with closeReason
+         * "stop_loss" on the next live tick. No-op if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @param payload - Optional commit payload with id and note
+         * @returns Promise that resolves when the stop-loss fill is queued
+         */
+        this.commitCreateStopLoss = async (symbol, context, payload = {}) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_COMMIT_CREATE_STOP_LOSS, {
+                symbol,
+                context,
+                payload,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_COMMIT_CREATE_STOP_LOSS);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_COMMIT_CREATE_STOP_LOSS);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_COMMIT_CREATE_STOP_LOSS);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_COMMIT_CREATE_STOP_LOSS));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_COMMIT_CREATE_STOP_LOSS));
+            }
+            await bt.strategyCoreService.createStopLoss(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }, payload);
+        };
         /**
          * Returns the in-memory deferred strategy-state snapshot for the current live iteration.
          *
@@ -60369,7 +61947,9 @@ const SUBJECT_ISOLATION_LIST = [
     validationSubject,
     signalNotifySubject,
     beforeStartSubject,
-    afterEndSubject
+    afterEndSubject,
+    scheduleEventSubject,
+    signalEventSubject,
 ];
 /**
  * Creates a snapshot function for a given subject by clearing its internal
@@ -68707,4 +70287,4 @@ const percentValue = (yesterdayValue, todayValue) => {
     return yesterdayValue / todayValue - 1;
 };
 
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Cron, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, PersistStrategyAdapter, PersistStrategyInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, beginContext, beginTime, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitCreateSignal, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getPriceScale, getRawCandles, getRiskSchema, getRuntimeInfo, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getStrategyStatus, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenAfterEnd, listenAfterEndOnce, listenBacktestProgress, listenBeforeStart, listenBeforeStartOnce, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toPlainString, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCandles, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Cron, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, PersistStrategyAdapter, PersistStrategyInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, beginContext, beginTime, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitCreateSignal, commitCreateStopLoss, commitCreateTakeProfit, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getPriceScale, getRawCandles, getRiskSchema, getRuntimeInfo, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getStrategyStatus, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenAfterEnd, listenAfterEndOnce, listenBacktestProgress, listenBeforeStart, listenBeforeStartOnce, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenScheduleEvent, listenScheduleEventOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalEvent, listenSignalEventOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toPlainString, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCandles, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };