backtest-kit 13.5.0 → 13.6.0

package/build/index.cjs

@@ -649,6 +649,15 @@ const DEFAULT_CONFIG = Object.freeze({ ...GLOBAL_CONFIG });
  * Consumers should implement retry logic in their listeners to handle transient synchronization failures.
  */
 const syncSubject = new functoolsKit.Subject();
+/**
+ * Pending-order synchronization emitter.
+ * Emitted on every live tick while a pending signal is monitored, BEFORE TP/SL/time evaluation.
+ * Asks the exchange whether the order is STILL pending (open).
+ *
+ * If a listener returns false OR throws, the order is treated as no longer open on the exchange
+ * and the framework closes the pending signal with closeReason "closed". Never emitted in backtest.
+ */
+const syncPendingSubject = new functoolsKit.Subject();
 /**
  * Global signal emitter for all trading events (live + backtest).
  * Emits all signal events regardless of execution mode.
@@ -856,6 +865,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     signalLiveEmitter: signalLiveEmitter,
     signalNotifySubject: signalNotifySubject,
     strategyCommitSubject: strategyCommitSubject,
+    syncPendingSubject: syncPendingSubject,
     syncSubject: syncSubject,
     validationSubject: validationSubject,
     walkerCompleteSubject: walkerCompleteSubject,
@@ -7075,6 +7085,64 @@ const CALL_SIGNAL_SYNC_CLOSE_FN = functoolsKit.trycatch(async (timestamp, curren
         errorEmitter.next(error);
     }
 });
+/**
+ * Calls onSignalPing callback for the pending-order synchronization event.
+ *
+ * Invoked at the start of the pending-signal monitoring block on every LIVE tick, BEFORE the
+ * framework evaluates TP/SL/time completion. It asks the external order management system
+ * whether the order backing this position is STILL pending (open) on the exchange.
+ *
+ * The Subject `await .next()` propagates listener exceptions passthrough, so the trycatch wrapper
+ * collapses both a thrown listener and an explicit `false` into `false` (defaultValue). A `false`
+ * result means the order is no longer open on the exchange and the caller closes the position with
+ * closeReason "closed". A missing/true result keeps the position under normal TP/SL monitoring.
+ */
+const CALL_SIGNAL_PING_FN = functoolsKit.trycatch(async (timestamp, currentPrice, signal, self) => {
+    const publicSignal = TO_PUBLIC_SIGNAL("pending", signal, currentPrice);
+    return await self.params.onSignalPing({
+        action: "signal-ping",
+        symbol: self.params.execution.context.symbol,
+        strategyName: self.params.strategyName,
+        exchangeName: self.params.exchangeName,
+        frameName: self.params.frameName,
+        backtest: self.params.execution.context.backtest,
+        signalId: signal.id,
+        timestamp,
+        signal: publicSignal,
+        currentPrice,
+        pnl: publicSignal.pnl,
+        peakProfit: publicSignal.peakProfit,
+        maxDrawdown: publicSignal.maxDrawdown,
+        position: publicSignal.position,
+        priceOpen: publicSignal.priceOpen,
+        priceTakeProfit: publicSignal.priceTakeProfit,
+        priceStopLoss: publicSignal.priceStopLoss,
+        originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
+        originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+        originalPriceOpen: publicSignal.originalPriceOpen,
+        scheduledAt: publicSignal.scheduledAt,
+        pendingAt: publicSignal.pendingAt,
+        totalEntries: publicSignal.totalEntries,
+        totalPartials: publicSignal.totalPartials,
+    });
+}, {
+    defaultValue: false,
+    fallback: (error, timestamp, currentPrice, signal, self) => {
+        const message = "ClientStrategy CALL_SIGNAL_PING_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+            data: {
+                timestamp,
+                currentPrice,
+                signalId: signal.id,
+            }
+        };
+        self.params.logger.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    }
+});
 /**
  * Calls onCommit callback with strategy commit event.
  *
@@ -8996,6 +9064,47 @@ const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason)
     await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
+/**
+ * Closes the pending signal with closeReason "closed" after the pending-order ping reported the
+ * order is no longer open on the exchange (CALL_SIGNAL_PING_FN returned false / threw).
+ *
+ * Unlike CLOSE_PENDING_SIGNAL_FN this does NOT re-confirm via onSignalSync — the ping already
+ * established the order is gone, so re-asking the broker would be redundant. Runs the same teardown
+ * (close callback, partial/breakeven clear, risk remove, setPendingSignal(null)). Live-only path.
+ */
+const CLOSE_PENDING_SIGNAL_AS_CLOSED_FN = async (self, signal, currentPrice) => {
+    const currentTime = self.params.execution.context.when.getTime();
+    const publicSignal = TO_PUBLIC_SIGNAL("pending", signal, currentPrice);
+    self.params.logger.info("ClientStrategy signal closed by pending-order ping (order no longer open on exchange)", {
+        symbol: self.params.execution.context.symbol,
+        signalId: signal.id,
+        priceClose: currentPrice,
+        pnlPercentage: publicSignal.pnl.pnlPercentage,
+    });
+    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);
+    // КРИТИЧНО: Очищаем состояние ClientBreakeven при закрытии позиции
+    await CALL_BREAKEVEN_CLEAR_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
+    await CALL_RISK_REMOVE_SIGNAL_FN(self, self.params.execution.context.symbol, currentTime, self.params.execution.context.backtest);
+    await self.setPendingSignal(null, currentPrice);
+    const result = {
+        action: "closed",
+        signal: publicSignal,
+        currentPrice: currentPrice,
+        closeReason: "closed",
+        closeTimestamp: currentTime,
+        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,
+        createdAt: currentTime,
+    };
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
+    return result;
+};
 const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice, backtest) => {
     let percentTp = 0;
     let percentSl = 0;
@@ -11033,6 +11142,16 @@ class ClientStrategy {
         }
         // Monitor pending signal
         const averagePrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+        // Pending-order ping: before evaluating TP/SL/time, confirm the order is STILL open on the
+        // exchange. CALL_SIGNAL_PING_FN returns false when the listener returns false OR throws
+        // (Subject .next passthrough), meaning the order is no longer pending — close with "closed".
+        // Skipped in backtest: there is no live exchange to query.
+        if (!this.params.execution.context.backtest) {
+            const stillPending = await CALL_SIGNAL_PING_FN(currentTime, averagePrice, this._pendingSignal, this);
+            if (!stillPending) {
+                return await CLOSE_PENDING_SIGNAL_AS_CLOSED_FN(this, this._pendingSignal, averagePrice);
+            }
+        }
         const closedResult = await CHECK_PENDING_SIGNAL_COMPLETION_FN(this, this._pendingSignal, averagePrice);
         if (closedResult) {
             return closedResult;
@@ -12881,6 +13000,32 @@ const CREATE_SYNC_FN = (self, strategyName, exchangeName, frameName, backtest) =
     },
     defaultValue: false,
 });
+/**
+ * If the syncPendingSubject listener or any registered action throws, it means the order backing the
+ * open position is no longer pending on the exchange (filled/cancelled/liquidated externally).
+ * The trycatch wrapper collapses a throw OR an explicit false into false, and ClientStrategy closes
+ * the pending signal with closeReason "closed". Skipped in backtest — there is no live exchange.
+ */
+const CREATE_SYNC_PENDING_FN = (self, strategyName, exchangeName, frameName, backtest) => functoolsKit.trycatch(async (event) => {
+    if (event.backtest) {
+        return true;
+    }
+    await syncPendingSubject.next(event);
+    await self.actionCoreService.orderPing(backtest, event, { strategyName, exchangeName, frameName });
+    return true;
+}, {
+    fallback: (error) => {
+        const message = "StrategyConnectionService CREATE_SYNC_PENDING_FN thrown. Order no longer pending on exchange";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: false,
+});
 /**
  * Emits signal tick results with correct execution context timestamp.
  * Wraps emitter calls in ExecutionContextService.runInContext to preserve
@@ -13317,6 +13462,7 @@ class StrategyConnectionService {
                 onDispose: CREATE_COMMIT_DISPOSE_FN(this),
                 onCommit: CREATE_COMMIT_FN(this),
                 onSignalSync: CREATE_SYNC_FN(this, strategyName, exchangeName, frameName, backtest),
+                onSignalPing: CREATE_SYNC_PENDING_FN(this, strategyName, exchangeName, frameName, backtest),
                 onHighestProfit: CREATE_HIGHEST_PROFIT_FN(this, strategyName, exchangeName, frameName, backtest),
                 onMaxDrawdown: CREATE_MAX_DRAWDOWN_FN(this, strategyName, exchangeName, frameName, backtest),
             });
@@ -16251,6 +16397,22 @@ class ActionProxy {
             await this._target.signalSync(event);
         }
     }
+    /**
+     * Gate for the pending-order ping (order still open on exchange?).
+     * NOT wrapped in trycatch — exceptions propagate to CREATE_SYNC_PENDING_FN.
+     *
+     * @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\"!");
+            console.error("");
+            console.error("You have been warned!");
+            await this._target.orderPing(event);
+        }
+    }
     /**
      * Cleans up resources with error capture.
      *
@@ -16470,6 +16632,15 @@ const CALL_SIGNAL_SYNC_CALLBACK_FN = async (self, event, strategyName, frameName
         await self.params.callbacks.onSignalSync(event, self.params.actionName, strategyName, frameName, isBacktest);
     }
 };
+/**
+ * Calls onOrderPing 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);
+    }
+};
 /** Wrapper to call onInit callback with error handling */
 const CALL_INIT_CALLBACK_FN = functoolsKit.trycatch(async (self, strategyName, frameName, backtest) => {
     if (self.params.callbacks?.onInit) {
@@ -16848,6 +17019,25 @@ class ClientAction {
         await CALL_SIGNAL_SYNC_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
     }
     ;
+    /**
+     * 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", {
+            actionName: this.params.actionName,
+            strategyName: this.params.strategyName,
+            frameName: this.params.frameName,
+        });
+        if (!this._handlerInstance) {
+            await this.waitForInit();
+        }
+        // Call handler method if defined — exceptions propagate
+        await this._handlerInstance?.orderPing(event);
+        // Call callback if defined — exceptions propagate
+        await CALL_ORDER_PING_CALLBACK_FN(this, event, this.params.strategyName, this.params.frameName, event.backtest);
+    }
+    ;
 }
 
 /**
@@ -17110,6 +17300,22 @@ class ActionConnectionService {
             const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
             await action.signalSync(event);
         };
+        /**
+         * Routes orderPing 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", {
+                backtest,
+                context,
+            });
+            const action = this.getAction(context.actionName, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await action.orderPing(event);
+        };
         /**
          * Disposes the ClientAction instance for the given action name.
          *
@@ -19334,6 +19540,24 @@ class ActionCoreService {
                 await this.actionConnectionService.signalSync(event, backtest, { actionName, ...context });
             }
         };
+        /**
+         * Gates the pending-order ping across all registered actions.
+         * NOT wrapped in trycatch — exceptions propagate to CREATE_SYNC_PENDING_FN.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @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", {
+                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 });
+            }
+        };
         /**
          * Disposes all ClientAction instances for the strategy.
          *
@@ -19802,6 +20026,29 @@ const VALID_METHOD_NAMES = [
     "riskRejection",
     "dispose",
 ];
+/**
+ * Exchange-integration handler methods that exist on IAction but are intentionally NOT in
+ * VALID_METHOD_NAMES. They are discouraged on action handlers: exchange synchronization belongs
+ * in the infrastructure domain layer (Broker.useBrokerAdapter), not in actions. Naming a handler
+ * 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"];
+/**
+ * Builds the dedicated error message for a discouraged exchange-integration handler method.
+ *
+ * @param actionName - Name of the action being validated
+ * @param methodName - The discouraged method name found on the handler
+ * @returns Multi-line error message redirecting to the Broker adapter
+ */
+const DISCOURAGED_METHOD_MESSAGE = (actionName, methodName) => functoolsKit.str.newline([
+    `ActionSchema ${actionName} contains discouraged method "${methodName}". `,
+    `Exchange integration must be implemented in Broker.useBrokerAdapter as the infrastructure domain layer, not in an action handler.`,
+    functoolsKit.typo.nbsp,
+    `Use Broker.useBrokerAdapter with onOrderPing (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}`,
+]);
 /**
  * Calculates the Levenshtein distance between two strings.
  *
@@ -19904,6 +20151,13 @@ const VALIDATE_CLASS_METHODS = (actionName, handler, self) => {
         }
         const descriptor = Object.getOwnPropertyDescriptor(handler.prototype, methodName);
         const isMethod = descriptor && typeof descriptor.value === "function";
+        if (isMethod && DISCOURAGED_METHOD_NAMES.includes(methodName)) {
+            const msg = DISCOURAGED_METHOD_MESSAGE(actionName, methodName);
+            self.loggerService.log(`actionValidationService exception thrown`, {
+                msg,
+            });
+            console.log(msg);
+        }
         if (isMethod && !VALID_METHOD_NAMES.includes(methodName)) {
             const suggestions = FIND_SUGGESTIONS(methodName, VALID_METHOD_NAMES);
             const lines = [
@@ -19943,6 +20197,14 @@ const VALIDATE_OBJECT_METHODS = (actionName, handler, self) => {
         if (methodName.startsWith("_")) {
             continue;
         }
+        if (typeof handler[methodName] === "function" &&
+            DISCOURAGED_METHOD_NAMES.includes(methodName)) {
+            const msg = DISCOURAGED_METHOD_MESSAGE(actionName, methodName);
+            self.loggerService.log(`actionValidationService exception thrown`, {
+                msg,
+            });
+            console.log(msg);
+        }
         if (typeof handler[methodName] === "function" &&
             !VALID_METHOD_NAMES.includes(methodName)) {
             const suggestions = FIND_SUGGESTIONS(methodName, VALID_METHOD_NAMES);
@@ -42161,6 +42423,7 @@ 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_PARTIAL_PROFIT = "BrokerAdapter.commitPartialProfit";
 const BROKER_METHOD_NAME_COMMIT_PARTIAL_LOSS = "BrokerAdapter.commitPartialLoss";
 const BROKER_METHOD_NAME_COMMIT_TRAILING_STOP = "BrokerAdapter.commitTrailingStop";
@@ -42174,6 +42437,7 @@ 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_PARTIAL_PROFIT = "BrokerBase.onPartialProfitCommit";
 const BROKER_BASE_METHOD_NAME_ON_PARTIAL_LOSS = "BrokerBase.onPartialLossCommit";
 const BROKER_BASE_METHOD_NAME_ON_TRAILING_STOP = "BrokerBase.onTrailingStopCommit";
@@ -42222,6 +42486,25 @@ class BrokerProxy {
         }
         throw new Error("BrokerProxy onSignalOpenCommit is not implemented");
     }
+    /**
+     * Forwards a pending-order ping to the underlying adapter.
+     *
+     * If the adapter does not implement `onOrderPing`, 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"
+     * result and SWALLOW transient/network errors (return normally), otherwise a connectivity blip
+     * would wrongly close an open position.
+     *
+     * @param payload - Pending ping details: symbol, signalId, position, prices, pnl, context, backtest flag.
+     */
+    async onOrderPing(payload) {
+        if (this._instance.onOrderPing) {
+            await this.waitForInit();
+            await this._instance.onOrderPing(payload);
+            return;
+        }
+    }
     /**
      * Forwards a signal-close event to the underlying adapter.
      * Throws if the adapter does not implement `onSignalCloseCommit`.
@@ -42451,6 +42734,32 @@ class BrokerAdapter {
                 await instance.onSignalCloseCommit(payload);
             }
         };
+        /**
+         * Forwards a pending-order ping to the registered broker adapter.
+         *
+         * Called automatically via syncPendingSubject 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. Exceptions are NOT swallowed: a throw from the adapter propagates up to
+         * syncPendingSubject.next() → CREATE_SYNC_PENDING_FN, which closes the position with "closed".
+         *
+         * @param payload - Pending ping details: symbol, position, prices, pnl, context, backtest flag
+         */
+        this.commitSignalPending = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_SIGNAL_PENDING, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            const instance = this.getInstance();
+            if (instance) {
+                await instance.onOrderPing(payload);
+            }
+        };
         /**
          * Intercepts a partial-profit close before DI-core mutation.
          *
@@ -42753,6 +43062,7 @@ class BrokerAdapter {
                     position: event.signal.position,
                     cost: event.signal.cost,
                     symbol: event.symbol,
+                    signalId: event.signalId,
                     priceTakeProfit: event.signal.priceTakeProfit,
                     priceStopLoss: event.signal.priceStopLoss,
                     priceOpen: event.signal.priceOpen,
@@ -42776,6 +43086,7 @@ class BrokerAdapter {
                     currentPrice: event.currentPrice,
                     cost: event.signal.cost,
                     symbol: event.symbol,
+                    signalId: event.signalId,
                     pnl: event.signal.pnl,
                     priceOpen: event.signal.priceOpen,
                     peakProfit: event.signal.peakProfit,
@@ -42792,7 +43103,29 @@ class BrokerAdapter {
                     backtest: event.backtest,
                 });
             });
-            const disposeFn = functoolsKit.compose(() => unSignalOpen(), () => unSignalClose());
+            const unSignalPending = syncPendingSubject.subscribe(async (event) => {
+                await this.commitSignalPending({
+                    position: event.position,
+                    currentPrice: event.currentPrice,
+                    symbol: event.symbol,
+                    signalId: event.signalId,
+                    priceOpen: event.priceOpen,
+                    priceTakeProfit: event.priceTakeProfit,
+                    priceStopLoss: event.priceStopLoss,
+                    pnl: event.pnl,
+                    peakProfit: event.peakProfit,
+                    maxDrawdown: event.maxDrawdown,
+                    totalEntries: event.totalEntries,
+                    totalPartials: event.totalPartials,
+                    context: {
+                        strategyName: event.strategyName,
+                        exchangeName: event.exchangeName,
+                        frameName: event.frameName,
+                    },
+                    backtest: event.backtest,
+                });
+            });
+            const disposeFn = functoolsKit.compose(() => unSignalOpen(), () => unSignalClose(), () => unSignalPending());
             return () => {
                 this.enable.clear();
                 disposeFn();
@@ -42965,6 +43298,44 @@ class BrokerBase {
             context: payload.context,
         });
     }
+    /**
+     * Called on every live tick while a pending signal is monitored, BEFORE TP/SL/time evaluation.
+     *
+     * Override to query the exchange for the order by `payload.signalId` and THROW ONLY when it is
+     * definitively NOT FOUND by that id (filled, cancelled, or liquidated externally) — the framework
+     * then closes the position with closeReason "closed". The default implementation logs and returns
+     * normally, which keeps the position under normal TP/SL monitoring.
+     *
+     * CRITICAL: swallow transient/network errors (timeout, 5xx, rate limit, disconnect) — return
+     * 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
+     *
+     * @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`);
+     *   }
+     * }
+     * ```
+     */
+    async onOrderPing(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).
      *
@@ -43363,6 +43734,7 @@ async function commitPartialProfit(symbol, percentToClose) {
     }
     await Broker.commitPartialProfit({
         symbol,
+        signalId: signalForProfit.id,
         percentToClose,
         cost: percentToCloseCost(percentToClose, investedCostForProfit),
         currentPrice,
@@ -43428,6 +43800,7 @@ async function commitPartialLoss(symbol, percentToClose) {
     }
     await Broker.commitPartialLoss({
         symbol,
+        signalId: signalForLoss.id,
         percentToClose,
         cost: percentToCloseCost(percentToClose, investedCostForLoss),
         currentPrice,
@@ -43509,6 +43882,7 @@ async function commitTrailingStop(symbol, percentShift, currentPrice) {
     }
     await Broker.commitTrailingStop({
         symbol,
+        signalId: signal.id,
         percentShift,
         currentPrice,
         newStopLossPrice: slPercentShiftToPrice(percentShift, signal.priceStopLoss, effectivePriceOpen, signal.position),
@@ -43589,6 +43963,7 @@ async function commitTrailingTake(symbol, percentShift, currentPrice) {
     }
     await Broker.commitTrailingTake({
         symbol,
+        signalId: signal.id,
         percentShift,
         currentPrice,
         newTakeProfitPrice: tpPercentShiftToPrice(percentShift, signal.priceTakeProfit, effectivePriceOpen, signal.position),
@@ -43640,6 +44015,7 @@ async function commitTrailingStopCost(symbol, newStopLossPrice) {
     }
     await Broker.commitTrailingStop({
         symbol,
+        signalId: signal.id,
         percentShift,
         currentPrice,
         newStopLossPrice,
@@ -43691,6 +44067,7 @@ async function commitTrailingTakeCost(symbol, newTakeProfitPrice) {
     }
     await Broker.commitTrailingTake({
         symbol,
+        signalId: signal.id,
         percentShift,
         currentPrice,
         newTakeProfitPrice,
@@ -43752,6 +44129,7 @@ async function commitBreakeven(symbol) {
     }
     await Broker.commitBreakeven({
         symbol,
+        signalId: signal.id,
         currentPrice,
         newStopLossPrice: breakevenNewStopLossPrice(effectivePriceOpen),
         newTakeProfitPrice: breakevenNewTakeProfitPrice(signal.priceTakeProfit, signal._trailingPriceTakeProfit),
@@ -43842,6 +44220,7 @@ async function commitAverageBuy(symbol, cost = GLOBAL_CONFIG.CC_POSITION_ENTRY_C
     }
     await Broker.commitAverageBuy({
         symbol,
+        signalId: signalForAvgBuy.id,
         currentPrice,
         cost,
         position: signalForAvgBuy.position,
@@ -44225,6 +44604,7 @@ async function commitPartialProfitCost(symbol, dollarAmount) {
     }
     await Broker.commitPartialProfit({
         symbol,
+        signalId: signalForProfitCost.id,
         percentToClose,
         cost: dollarAmount,
         currentPrice,
@@ -44293,6 +44673,7 @@ async function commitPartialLossCost(symbol, dollarAmount) {
     }
     await Broker.commitPartialLoss({
         symbol,
+        signalId: signalForLossCost.id,
         percentToClose,
         cost: dollarAmount,
         currentPrice,
@@ -48847,6 +49228,7 @@ class BacktestUtils {
             }
             await Broker.commitPartialProfit({
                 symbol,
+                signalId: signalForProfit.id,
                 percentToClose,
                 cost: percentToCloseCost(percentToClose, investedCostForProfit),
                 currentPrice,
@@ -48918,6 +49300,7 @@ class BacktestUtils {
             }
             await Broker.commitPartialLoss({
                 symbol,
+                signalId: signalForLoss.id,
                 percentToClose,
                 cost: percentToCloseCost(percentToClose, investedCostForLoss),
                 currentPrice,
@@ -48991,6 +49374,7 @@ class BacktestUtils {
             }
             await Broker.commitPartialProfit({
                 symbol,
+                signalId: signalForProfitCost.id,
                 percentToClose,
                 cost: dollarAmount,
                 currentPrice,
@@ -49064,6 +49448,7 @@ class BacktestUtils {
             }
             await Broker.commitPartialLoss({
                 symbol,
+                signalId: signalForLossCost.id,
                 percentToClose,
                 cost: dollarAmount,
                 currentPrice,
@@ -49150,6 +49535,7 @@ class BacktestUtils {
             }
             await Broker.commitTrailingStop({
                 symbol,
+                signalId: signal.id,
                 percentShift,
                 currentPrice,
                 newStopLossPrice: slPercentShiftToPrice(percentShift, signal.priceStopLoss, effectivePriceOpen, signal.position),
@@ -49235,6 +49621,7 @@ class BacktestUtils {
             }
             await Broker.commitTrailingTake({
                 symbol,
+                signalId: signal.id,
                 percentShift,
                 currentPrice,
                 newTakeProfitPrice: tpPercentShiftToPrice(percentShift, signal.priceTakeProfit, effectivePriceOpen, signal.position),
@@ -49289,6 +49676,7 @@ class BacktestUtils {
             }
             await Broker.commitTrailingStop({
                 symbol,
+                signalId: signal.id,
                 percentShift,
                 currentPrice,
                 newStopLossPrice,
@@ -49343,6 +49731,7 @@ class BacktestUtils {
             }
             await Broker.commitTrailingTake({
                 symbol,
+                signalId: signal.id,
                 percentShift,
                 currentPrice,
                 newTakeProfitPrice,
@@ -49404,6 +49793,7 @@ class BacktestUtils {
             }
             await Broker.commitBreakeven({
                 symbol,
+                signalId: signal.id,
                 currentPrice,
                 newStopLossPrice: breakevenNewStopLossPrice(effectivePriceOpen),
                 newTakeProfitPrice: breakevenNewTakeProfitPrice(signal.priceTakeProfit, signal._trailingPriceTakeProfit),
@@ -49503,6 +49893,7 @@ class BacktestUtils {
             }
             await Broker.commitAverageBuy({
                 symbol,
+                signalId: signalForAvgBuy.id,
                 currentPrice,
                 cost,
                 position: signalForAvgBuy.position,
@@ -51750,6 +52141,7 @@ class LiveUtils {
             }
             await Broker.commitPartialProfit({
                 symbol,
+                signalId: signalForProfit.id,
                 percentToClose,
                 cost: percentToCloseCost(percentToClose, investedCost),
                 currentPrice,
@@ -51840,6 +52232,7 @@ class LiveUtils {
             }
             await Broker.commitPartialLoss({
                 symbol,
+                signalId: signalForLoss.id,
                 percentToClose,
                 cost: percentToCloseCost(percentToClose, investedCost),
                 currentPrice,
@@ -51932,6 +52325,7 @@ class LiveUtils {
             }
             await Broker.commitPartialProfit({
                 symbol,
+                signalId: signalForProfitCost.id,
                 percentToClose,
                 cost: dollarAmount,
                 currentPrice,
@@ -52024,6 +52418,7 @@ class LiveUtils {
             }
             await Broker.commitPartialLoss({
                 symbol,
+                signalId: signalForLossCost.id,
                 percentToClose,
                 cost: dollarAmount,
                 currentPrice,
@@ -52129,6 +52524,7 @@ class LiveUtils {
             }
             await Broker.commitTrailingStop({
                 symbol,
+                signalId: signal.id,
                 percentShift,
                 currentPrice,
                 newStopLossPrice: slPercentShiftToPrice(percentShift, signal.priceStopLoss, effectivePriceOpen, signal.position),
@@ -52229,6 +52625,7 @@ class LiveUtils {
             }
             await Broker.commitTrailingTake({
                 symbol,
+                signalId: signal.id,
                 percentShift,
                 currentPrice,
                 newTakeProfitPrice: tpPercentShiftToPrice(percentShift, signal.priceTakeProfit, effectivePriceOpen, signal.position),
@@ -52299,6 +52696,7 @@ class LiveUtils {
             }
             await Broker.commitTrailingStop({
                 symbol,
+                signalId: signal.id,
                 percentShift,
                 currentPrice,
                 newStopLossPrice,
@@ -52369,6 +52767,7 @@ class LiveUtils {
             }
             await Broker.commitTrailingTake({
                 symbol,
+                signalId: signal.id,
                 percentShift,
                 currentPrice,
                 newTakeProfitPrice,
@@ -52446,6 +52845,7 @@ class LiveUtils {
             }
             await Broker.commitBreakeven({
                 symbol,
+                signalId: signal.id,
                 currentPrice,
                 newStopLossPrice: breakevenNewStopLossPrice(effectivePriceOpen),
                 newTakeProfitPrice: breakevenNewTakeProfitPrice(signal.priceTakeProfit, signal._trailingPriceTakeProfit),
@@ -52563,6 +52963,7 @@ class LiveUtils {
             }
             await Broker.commitAverageBuy({
                 symbol,
+                signalId: signalForAvgBuy.id,
                 currentPrice,
                 cost,
                 position: signalForAvgBuy.position,
@@ -59984,6 +60385,7 @@ const SUBJECT_ISOLATION_LIST = [
     signalLiveEmitter,
     strategyCommitSubject,
     syncSubject,
+    syncPendingSubject,
     validationSubject,
     signalNotifySubject,
     beforeStartSubject,