backtest-kit 13.6.0 → 14.1.0

package/build/index.cjs

@@ -768,6 +768,22 @@ const riskSubject = new functoolsKit.Subject();
  * Allows users to track scheduled signal lifecycle and implement custom cancellation logic.
  */
 const schedulePingSubject = new functoolsKit.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 functoolsKit.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 functoolsKit.Subject();
 /**
  * Active ping emitter for active pending signal monitoring events.
  * Emits every minute when an active pending signal is being monitored.
@@ -858,10 +874,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,
@@ -1929,7 +1947,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;
                 }
@@ -7673,6 +7691,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);
@@ -7753,6 +7775,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) => {
@@ -8286,6 +8310,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",
@@ -8342,6 +8367,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",
@@ -8435,6 +8461,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",
@@ -8569,6 +8596,53 @@ const CALL_SCHEDULE_CALLBACKS_FN = functoolsKit.trycatch(beginTime(async (self,
         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 = functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.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 = functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        self.params.logger.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 const CALL_CANCEL_CALLBACKS_FN = functoolsKit.trycatch(beginTime(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
         if (self.params.callbacks?.onCancel) {
@@ -8944,6 +9018,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",
@@ -8974,6 +9049,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",
@@ -9040,6 +9116,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);
@@ -9081,6 +9158,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);
@@ -9251,6 +9329,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",
@@ -9363,6 +9442,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;
@@ -9393,6 +9473,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);
@@ -9451,6 +9532,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);
@@ -9473,6 +9555,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;
@@ -9595,6 +9750,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 };
@@ -9690,6 +9846,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 (КРИТИЧНО!)
@@ -9925,6 +10095,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
@@ -9998,6 +10182,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 может существовать (новый сигнал после закрытия позиции)
@@ -10891,6 +11079,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 = {
@@ -10951,6 +11140,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 при закрытии позиции
@@ -10976,6 +11166,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);
@@ -11076,6 +11292,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 = {
@@ -11226,6 +11443,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",
@@ -11311,6 +11529,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");
         }
@@ -11428,12 +11664,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;
@@ -11651,9 +11892,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,
@@ -11673,6 +12002,8 @@ class ClientStrategy {
             closedSignal: this._closedSignal,
             cancelledSignal: this._cancelledSignal,
             activatedSignal: this._activatedSignal,
+            takeProfitSignal: this._takeProfitSignal,
+            stopLossSignal: this._stopLossSignal,
         };
     }
     /**
@@ -13011,7 +13342,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) => {
@@ -13165,6 +13496,81 @@ const CREATE_COMMIT_SCHEDULE_PING_FN = (self) => functoolsKit.trycatch(async (sy
     },
     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) => functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.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) => functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.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.
  *
@@ -13457,6 +13863,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),
@@ -14476,6 +14884,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.
          *
@@ -16119,6 +16571,54 @@ const CALL_PING_IDLE_FN = functoolsKit.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 = functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.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 = functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.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.
  */
@@ -16345,6 +16845,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.
      *
@@ -16403,14 +16928,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);
         }
     }
     /**
@@ -16572,6 +17097,40 @@ const CALL_PING_SCHEDULED_CALLBACK_FN = functoolsKit.trycatch(async (self, event
         errorEmitter.next(error);
     },
 });
+/** Wrapper to call scheduled lifecycle (creation / cancellation) callback with error handling */
+const CALL_SCHEDULE_EVENT_CALLBACK_FN = functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.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 = functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.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 = functoolsKit.trycatch(async (self, event, strategyName, frameName, backtest) => {
     if (self.params.callbacks?.onPingIdle) {
@@ -16633,12 +17192,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 */
@@ -16946,6 +17505,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.
      */
@@ -17023,8 +17628,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,
@@ -17033,7 +17638,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);
     }
@@ -17238,6 +17843,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.
          *
@@ -17301,20 +17936,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.
@@ -18182,6 +18817,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.
          *
@@ -19458,6 +20141,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.
          *
@@ -19548,14 +20273,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 });
             }
         };
         /**
@@ -20023,6 +20748,8 @@ const VALID_METHOD_NAMES = [
     "partialLossAvailable",
     "pingScheduled",
     "pingActive",
+    "scheduleEvent",
+    "pendingEvent",
     "riskRejection",
     "dispose",
 ];
@@ -20033,7 +20760,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.
  *
@@ -20045,7 +20772,7 @@ const DISCOURAGED_METHOD_MESSAGE = (actionName, methodName) => functoolsKit.str.
     `ActionSchema ${actionName} contains discouraged method "${methodName}". `,
     `Exchange integration must be implemented in Broker.useBrokerAdapter as the infrastructure domain layer, not in an action handler.`,
     functoolsKit.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.`,
     functoolsKit.typo.nbsp,
     `If you want to keep this property name use one of these patterns: _${methodName} or #${methodName}`,
 ]);
@@ -42424,6 +43151,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";
@@ -42437,7 +43171,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";
@@ -42489,7 +43230,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"
@@ -42498,10 +43239,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;
         }
     }
@@ -42757,7 +43589,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);
             }
         };
         /**
@@ -43125,7 +44128,98 @@ class BrokerAdapter {
                     backtest: event.backtest,
                 });
             });
-            const disposeFn = functoolsKit.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 = functoolsKit.compose(() => unSignalOpen(), () => unSignalClose(), () => unSignalPending(), () => unActivePing(), () => unSchedulePing(), () => unIdlePing(), () => unScheduleEvent(), () => unSignalEvent());
             return () => {
                 this.enable.clear();
                 disposeFn();
@@ -43271,24 +44365,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
+     *   }
      * }
      * ```
      */
@@ -43310,47 +44412,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 });
      * }
      * ```
@@ -43606,6 +44819,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.
@@ -45715,6 +46930,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.
@@ -45817,6 +47100,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";
@@ -46919,6 +48206,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(functoolsKit.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(functoolsKit.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.
  *
@@ -47416,6 +48834,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";
@@ -49152,6 +50572,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.
          *
@@ -50137,6 +51641,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";
@@ -52050,6 +53556,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.
          *
@@ -60389,7 +61967,9 @@ const SUBJECT_ISOLATION_LIST = [
     validationSubject,
     signalNotifySubject,
     beforeStartSubject,
-    afterEndSubject
+    afterEndSubject,
+    scheduleEventSubject,
+    signalEventSubject,
 ];
 /**
  * Creates a snapshot function for a given subject by clearing its internal
@@ -68837,6 +70417,8 @@ exports.commitBreakeven = commitBreakeven;
 exports.commitCancelScheduled = commitCancelScheduled;
 exports.commitClosePending = commitClosePending;
 exports.commitCreateSignal = commitCreateSignal;
+exports.commitCreateStopLoss = commitCreateStopLoss;
+exports.commitCreateTakeProfit = commitCreateTakeProfit;
 exports.commitPartialLoss = commitPartialLoss;
 exports.commitPartialLossCost = commitPartialLossCost;
 exports.commitPartialProfit = commitPartialProfit;
@@ -68970,11 +70552,15 @@ exports.listenPartialProfitAvailableOnce = listenPartialProfitAvailableOnce;
 exports.listenPerformance = listenPerformance;
 exports.listenRisk = listenRisk;
 exports.listenRiskOnce = listenRiskOnce;
+exports.listenScheduleEvent = listenScheduleEvent;
+exports.listenScheduleEventOnce = listenScheduleEventOnce;
 exports.listenSchedulePing = listenSchedulePing;
 exports.listenSchedulePingOnce = listenSchedulePingOnce;
 exports.listenSignal = listenSignal;
 exports.listenSignalBacktest = listenSignalBacktest;
 exports.listenSignalBacktestOnce = listenSignalBacktestOnce;
+exports.listenSignalEvent = listenSignalEvent;
+exports.listenSignalEventOnce = listenSignalEventOnce;
 exports.listenSignalLive = listenSignalLive;
 exports.listenSignalLiveOnce = listenSignalLiveOnce;
 exports.listenSignalNotify = listenSignalNotify;