backtest-kit 3.8.1 → 4.0.1

package/build/index.mjs

@@ -7359,6 +7359,52 @@ class ClientStrategy {
         await PersistSignalAdapter.writeSignalData(this._pendingSignal, symbol, this.params.strategyName, this.params.exchangeName);
         // Commit will be emitted in tick() with correct currentTime
     }
+    /**
+     * Validates preconditions for partialProfit without mutating state.
+     *
+     * Returns false (never throws) when any condition would cause partialProfit to fail or skip.
+     * Use this to pre-check before calling partialProfit to avoid needing to handle exceptions.
+     *
+     * @param symbol - Trading pair symbol
+     * @param percentToClose - Percentage of position to close (0-100)
+     * @param currentPrice - Current market price (must be in profit direction)
+     * @returns boolean - true if partialProfit would execute, false otherwise
+     */
+    async validatePartialProfit(symbol, percentToClose, currentPrice) {
+        this.params.logger.debug("ClientStrategy validatePartialProfit", {
+            symbol,
+            percentToClose,
+            currentPrice,
+            hasPendingSignal: this._pendingSignal !== null,
+        });
+        if (!this._pendingSignal)
+            return false;
+        if (typeof percentToClose !== "number" || !isFinite(percentToClose))
+            return false;
+        if (percentToClose <= 0)
+            return false;
+        if (percentToClose > 100)
+            return false;
+        if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0)
+            return false;
+        const effectivePriceOpen = getEffectivePriceOpen(this._pendingSignal);
+        if (this._pendingSignal.position === "long" && currentPrice <= effectivePriceOpen)
+            return false;
+        if (this._pendingSignal.position === "short" && currentPrice >= effectivePriceOpen)
+            return false;
+        const effectiveTakeProfit = this._pendingSignal._trailingPriceTakeProfit ?? this._pendingSignal.priceTakeProfit;
+        if (this._pendingSignal.position === "long" && currentPrice >= effectiveTakeProfit)
+            return false;
+        if (this._pendingSignal.position === "short" && currentPrice <= effectiveTakeProfit)
+            return false;
+        const { totalClosedPercent, remainingCostBasis } = getTotalClosed(this._pendingSignal);
+        const totalInvested = (this._pendingSignal._entry ?? []).reduce((s, e) => s + e.cost, 0) || GLOBAL_CONFIG.CC_POSITION_ENTRY_COST;
+        const newPartialDollar = (percentToClose / 100) * remainingCostBasis;
+        const newTotalClosedDollar = (totalClosedPercent / 100) * totalInvested + newPartialDollar;
+        if (newTotalClosedDollar > totalInvested)
+            return false;
+        return true;
+    }
     /**
      * Executes partial close at profit level (moving toward TP).
      *
@@ -7494,6 +7540,52 @@ class ClientStrategy {
         });
         return true;
     }
+    /**
+     * Validates preconditions for partialLoss without mutating state.
+     *
+     * Returns false (never throws) when any condition would cause partialLoss to fail or skip.
+     * Use this to pre-check before calling partialLoss to avoid needing to handle exceptions.
+     *
+     * @param symbol - Trading pair symbol
+     * @param percentToClose - Percentage of position to close (0-100)
+     * @param currentPrice - Current market price (must be in loss direction)
+     * @returns boolean - true if partialLoss would execute, false otherwise
+     */
+    async validatePartialLoss(symbol, percentToClose, currentPrice) {
+        this.params.logger.debug("ClientStrategy validatePartialLoss", {
+            symbol,
+            percentToClose,
+            currentPrice,
+            hasPendingSignal: this._pendingSignal !== null,
+        });
+        if (!this._pendingSignal)
+            return false;
+        if (typeof percentToClose !== "number" || !isFinite(percentToClose))
+            return false;
+        if (percentToClose <= 0)
+            return false;
+        if (percentToClose > 100)
+            return false;
+        if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0)
+            return false;
+        const effectivePriceOpen = getEffectivePriceOpen(this._pendingSignal);
+        if (this._pendingSignal.position === "long" && currentPrice >= effectivePriceOpen)
+            return false;
+        if (this._pendingSignal.position === "short" && currentPrice <= effectivePriceOpen)
+            return false;
+        const effectiveStopLoss = this._pendingSignal._trailingPriceStopLoss ?? this._pendingSignal.priceStopLoss;
+        if (this._pendingSignal.position === "long" && currentPrice <= effectiveStopLoss)
+            return false;
+        if (this._pendingSignal.position === "short" && currentPrice >= effectiveStopLoss)
+            return false;
+        const { totalClosedPercent, remainingCostBasis } = getTotalClosed(this._pendingSignal);
+        const totalInvested = (this._pendingSignal._entry ?? []).reduce((s, e) => s + e.cost, 0) || GLOBAL_CONFIG.CC_POSITION_ENTRY_COST;
+        const newPartialDollar = (percentToClose / 100) * remainingCostBasis;
+        const newTotalClosedDollar = (totalClosedPercent / 100) * totalInvested + newPartialDollar;
+        if (newTotalClosedDollar > totalInvested)
+            return false;
+        return true;
+    }
     /**
      * Executes partial close at loss level (moving toward SL).
      *
@@ -7629,6 +7721,82 @@ class ClientStrategy {
         });
         return true;
     }
+    /**
+     * Validates preconditions for breakeven without mutating state.
+     *
+     * Returns false (never throws) when any condition would cause breakeven to fail or skip.
+     * Mirrors the full BREAKEVEN_FN condition logic including threshold, trailing state and intrusion checks.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price to check threshold
+     * @returns boolean - true if breakeven would execute, false otherwise
+     */
+    async validateBreakeven(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy validateBreakeven", {
+            symbol,
+            currentPrice,
+            hasPendingSignal: this._pendingSignal !== null,
+        });
+        if (!this._pendingSignal)
+            return false;
+        if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0)
+            return false;
+        const signal = this._pendingSignal;
+        const breakevenPrice = getEffectivePriceOpen(signal);
+        const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+        if (signal.position === "long" && breakevenPrice >= effectiveTakeProfit)
+            return false;
+        if (signal.position === "short" && breakevenPrice <= effectiveTakeProfit)
+            return false;
+        const breakevenThresholdPercent = (GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE + GLOBAL_CONFIG.CC_PERCENT_FEE) * 2;
+        if (signal._trailingPriceStopLoss !== undefined) {
+            const trailingStopLoss = signal._trailingPriceStopLoss;
+            if (signal.position === "long") {
+                const isPositiveTrailing = trailingStopLoss > breakevenPrice;
+                if (isPositiveTrailing)
+                    return true; // already protecting profit
+                const thresholdPrice = breakevenPrice * (1 + breakevenThresholdPercent / 100);
+                const isThresholdReached = currentPrice >= thresholdPrice;
+                if (!isThresholdReached || breakevenPrice <= trailingStopLoss)
+                    return false;
+                if (currentPrice < breakevenPrice)
+                    return false; // price intrusion
+                return true;
+            }
+            else {
+                const isPositiveTrailing = trailingStopLoss < breakevenPrice;
+                if (isPositiveTrailing)
+                    return true; // already protecting profit
+                const thresholdPrice = breakevenPrice * (1 - breakevenThresholdPercent / 100);
+                const isThresholdReached = currentPrice <= thresholdPrice;
+                if (!isThresholdReached || breakevenPrice >= trailingStopLoss)
+                    return false;
+                if (currentPrice > breakevenPrice)
+                    return false; // price intrusion
+                return true;
+            }
+        }
+        const currentStopLoss = signal.priceStopLoss;
+        if (signal.position === "long") {
+            const thresholdPrice = breakevenPrice * (1 + breakevenThresholdPercent / 100);
+            const isThresholdReached = currentPrice >= thresholdPrice;
+            const canMove = isThresholdReached && currentStopLoss < breakevenPrice;
+            if (!canMove)
+                return false;
+            if (currentPrice < breakevenPrice)
+                return false;
+        }
+        else {
+            const thresholdPrice = breakevenPrice * (1 - breakevenThresholdPercent / 100);
+            const isThresholdReached = currentPrice <= thresholdPrice;
+            const canMove = isThresholdReached && currentStopLoss > breakevenPrice;
+            if (!canMove)
+                return false;
+            if (currentPrice > breakevenPrice)
+                return false;
+        }
+        return true;
+    }
     /**
      * Moves stop-loss to breakeven (entry price) when price reaches threshold.
      *
@@ -7751,6 +7919,65 @@ class ClientStrategy {
         });
         return true;
     }
+    /**
+     * Validates preconditions for trailingStop without mutating state.
+     *
+     * Returns false (never throws) when any condition would cause trailingStop to fail or skip.
+     * Includes absorption check: returns false if new SL would not improve on the current trailing SL.
+     *
+     * @param symbol - Trading pair symbol
+     * @param percentShift - Percentage shift of ORIGINAL SL distance [-100, 100], excluding 0
+     * @param currentPrice - Current market price to check for intrusion
+     * @returns boolean - true if trailingStop would execute, false otherwise
+     */
+    async validateTrailingStop(symbol, percentShift, currentPrice) {
+        this.params.logger.debug("ClientStrategy validateTrailingStop", {
+            symbol,
+            percentShift,
+            currentPrice,
+            hasPendingSignal: this._pendingSignal !== null,
+        });
+        if (!this._pendingSignal)
+            return false;
+        if (typeof percentShift !== "number" || !isFinite(percentShift))
+            return false;
+        if (percentShift < -100 || percentShift > 100)
+            return false;
+        if (percentShift === 0)
+            return false;
+        if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0)
+            return false;
+        const signal = this._pendingSignal;
+        const effectivePriceOpen = getEffectivePriceOpen(signal);
+        const slDistancePercent = Math.abs((effectivePriceOpen - signal.priceStopLoss) / effectivePriceOpen * 100);
+        const newSlDistancePercent = slDistancePercent + percentShift;
+        let newStopLoss;
+        if (signal.position === "long") {
+            newStopLoss = effectivePriceOpen * (1 - newSlDistancePercent / 100);
+        }
+        else {
+            newStopLoss = effectivePriceOpen * (1 + newSlDistancePercent / 100);
+        }
+        // Intrusion check (mirrors trailingStop method: applied before TRAILING_STOP_LOSS_FN, for all calls)
+        if (signal.position === "long" && currentPrice < newStopLoss)
+            return false;
+        if (signal.position === "short" && currentPrice > newStopLoss)
+            return false;
+        const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+        if (signal.position === "long" && newStopLoss >= effectiveTakeProfit)
+            return false;
+        if (signal.position === "short" && newStopLoss <= effectiveTakeProfit)
+            return false;
+        // Absorption check (mirrors TRAILING_STOP_LOSS_FN: first call is unconditional)
+        const currentTrailingSL = signal._trailingPriceStopLoss;
+        if (currentTrailingSL !== undefined) {
+            if (signal.position === "long" && newStopLoss <= currentTrailingSL)
+                return false;
+            if (signal.position === "short" && newStopLoss >= currentTrailingSL)
+                return false;
+        }
+        return true;
+    }
     /**
      * Adjusts trailing stop-loss by shifting distance between entry and original SL.
      *
@@ -7939,6 +8166,65 @@ class ClientStrategy {
         });
         return true;
     }
+    /**
+     * Validates preconditions for trailingTake without mutating state.
+     *
+     * Returns false (never throws) when any condition would cause trailingTake to fail or skip.
+     * Includes absorption check: returns false if new TP would not improve on the current trailing TP.
+     *
+     * @param symbol - Trading pair symbol
+     * @param percentShift - Percentage adjustment to ORIGINAL TP distance (-100 to 100)
+     * @param currentPrice - Current market price to check for intrusion
+     * @returns boolean - true if trailingTake would execute, false otherwise
+     */
+    async validateTrailingTake(symbol, percentShift, currentPrice) {
+        this.params.logger.debug("ClientStrategy validateTrailingTake", {
+            symbol,
+            percentShift,
+            currentPrice,
+            hasPendingSignal: this._pendingSignal !== null,
+        });
+        if (!this._pendingSignal)
+            return false;
+        if (typeof percentShift !== "number" || !isFinite(percentShift))
+            return false;
+        if (percentShift < -100 || percentShift > 100)
+            return false;
+        if (percentShift === 0)
+            return false;
+        if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0)
+            return false;
+        const signal = this._pendingSignal;
+        const effectivePriceOpen = getEffectivePriceOpen(signal);
+        const tpDistancePercent = Math.abs((signal.priceTakeProfit - effectivePriceOpen) / effectivePriceOpen * 100);
+        const newTpDistancePercent = tpDistancePercent + percentShift;
+        let newTakeProfit;
+        if (signal.position === "long") {
+            newTakeProfit = effectivePriceOpen * (1 + newTpDistancePercent / 100);
+        }
+        else {
+            newTakeProfit = effectivePriceOpen * (1 - newTpDistancePercent / 100);
+        }
+        // Intrusion check (mirrors trailingTake method: applied before TRAILING_TAKE_PROFIT_FN, for all calls)
+        if (signal.position === "long" && currentPrice > newTakeProfit)
+            return false;
+        if (signal.position === "short" && currentPrice < newTakeProfit)
+            return false;
+        const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
+        if (signal.position === "long" && newTakeProfit <= effectiveStopLoss)
+            return false;
+        if (signal.position === "short" && newTakeProfit >= effectiveStopLoss)
+            return false;
+        // Absorption check (mirrors TRAILING_TAKE_PROFIT_FN: first call is unconditional)
+        const currentTrailingTP = signal._trailingPriceTakeProfit;
+        if (currentTrailingTP !== undefined) {
+            if (signal.position === "long" && newTakeProfit >= currentTrailingTP)
+                return false;
+            if (signal.position === "short" && newTakeProfit <= currentTrailingTP)
+                return false;
+        }
+        return true;
+    }
     /**
      * Adjusts the trailing take-profit distance for an active pending signal.
      *
@@ -8113,6 +8399,41 @@ class ClientStrategy {
         });
         return true;
     }
+    /**
+     * Validates preconditions for averageBuy without mutating state.
+     *
+     * Returns false (never throws) when any condition would cause averageBuy to fail or skip.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - New entry price to add
+     * @returns boolean - true if averageBuy would execute, false otherwise
+     */
+    async validateAverageBuy(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy validateAverageBuy", {
+            symbol,
+            currentPrice,
+            hasPendingSignal: this._pendingSignal !== null,
+        });
+        if (!this._pendingSignal)
+            return false;
+        if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0)
+            return false;
+        const signal = this._pendingSignal;
+        const entries = (!signal._entry || signal._entry.length === 0)
+            ? [{ price: signal.priceOpen, cost: GLOBAL_CONFIG.CC_POSITION_ENTRY_COST }]
+            : signal._entry;
+        if (signal.position === "long") {
+            const minEntryPrice = Math.min(...entries.map((e) => e.price));
+            if (!GLOBAL_CONFIG.CC_ENABLE_DCA_EVERYWHERE && currentPrice >= minEntryPrice)
+                return false;
+        }
+        else {
+            const maxEntryPrice = Math.max(...entries.map((e) => e.price));
+            if (!GLOBAL_CONFIG.CC_ENABLE_DCA_EVERYWHERE && currentPrice <= maxEntryPrice)
+                return false;
+        }
+        return true;
+    }
     /**
      * Adds a new averaging entry to an open position (DCA — Dollar Cost Averaging).
      *
@@ -8498,12 +8819,22 @@ const Risk = new RiskUtils();
  */
 const CREATE_SYNC_FN = (self, strategyName, exchangeName, frameName, backtest) => trycatch(async (event) => {
     if (event.backtest) {
-        return;
+        return true;
     }
     await syncSubject.next(event);
     await self.actionCoreService.signalSync(backtest, event, { strategyName, exchangeName, frameName });
     return true;
 }, {
+    fallback: (error) => {
+        const message = "StrategyConnectionService CREATE_SYNC_FN thrown. Broker rejected order request";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
     defaultValue: false,
 });
 /**
@@ -9204,6 +9535,21 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             await strategy.closePending(symbol, backtest, closeId);
         };
+        /**
+         * Checks whether `partialProfit` would succeed without executing it.
+         * Delegates to `ClientStrategy.validatePartialProfit()` — no throws, pure boolean result.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param percentToClose - Percentage of position to check (0-100]
+         * @param currentPrice - Current market price to validate against
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if `partialProfit` would execute, false otherwise
+         */
+        this.validatePartialProfit = (backtest, symbol, percentToClose, currentPrice, context) => {
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return Promise.resolve(strategy.validatePartialProfit(symbol, percentToClose, currentPrice));
+        };
         /**
          * Executes partial close at profit level (moving toward TP).
          *
@@ -9245,6 +9591,21 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.partialProfit(symbol, percentToClose, currentPrice, backtest);
         };
+        /**
+         * Checks whether `partialLoss` would succeed without executing it.
+         * Delegates to `ClientStrategy.validatePartialLoss()` — no throws, pure boolean result.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param percentToClose - Percentage of position to check (0-100]
+         * @param currentPrice - Current market price to validate against
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if `partialLoss` would execute, false otherwise
+         */
+        this.validatePartialLoss = (backtest, symbol, percentToClose, currentPrice, context) => {
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return Promise.resolve(strategy.validatePartialLoss(symbol, percentToClose, currentPrice));
+        };
         /**
          * Executes partial close at loss level (moving toward SL).
          *
@@ -9286,6 +9647,21 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.partialLoss(symbol, percentToClose, currentPrice, backtest);
         };
+        /**
+         * Checks whether `trailingStop` would succeed without executing it.
+         * Delegates to `ClientStrategy.validateTrailingStop()` — no throws, pure boolean result.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage shift of ORIGINAL SL distance [-100, 100], excluding 0
+         * @param currentPrice - Current market price to validate against
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if `trailingStop` would execute, false otherwise
+         */
+        this.validateTrailingStop = (backtest, symbol, percentShift, currentPrice, context) => {
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return Promise.resolve(strategy.validateTrailingStop(symbol, percentShift, currentPrice));
+        };
         /**
          * Adjusts the trailing stop-loss distance for an active pending signal.
          *
@@ -9325,6 +9701,21 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.trailingStop(symbol, percentShift, currentPrice, backtest);
         };
+        /**
+         * Checks whether `trailingTake` would succeed without executing it.
+         * Delegates to `ClientStrategy.validateTrailingTake()` — no throws, pure boolean result.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage adjustment to ORIGINAL TP distance [-100, 100], excluding 0
+         * @param currentPrice - Current market price to validate against
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if `trailingTake` would execute, false otherwise
+         */
+        this.validateTrailingTake = (backtest, symbol, percentShift, currentPrice, context) => {
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return Promise.resolve(strategy.validateTrailingTake(symbol, percentShift, currentPrice));
+        };
         /**
          * Adjusts the trailing take-profit distance for an active pending signal.
          *
@@ -9364,6 +9755,20 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.trailingTake(symbol, percentShift, currentPrice, backtest);
         };
+        /**
+         * Checks whether `breakeven` would succeed without executing it.
+         * Delegates to `ClientStrategy.validateBreakeven()` — no throws, pure boolean result.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price to validate against
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if `breakeven` would execute, false otherwise
+         */
+        this.validateBreakeven = (backtest, symbol, currentPrice, context) => {
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return Promise.resolve(strategy.validateBreakeven(symbol, currentPrice));
+        };
         /**
          * Delegates to ClientStrategy.breakeven() with current execution context.
          *
@@ -9429,6 +9834,20 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.activateScheduled(symbol, backtest, activateId);
         };
+        /**
+         * Checks whether `averageBuy` would succeed without executing it.
+         * Delegates to `ClientStrategy.validateAverageBuy()` — no throws, pure boolean result.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - New entry price to validate
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if `averageBuy` would execute, false otherwise
+         */
+        this.validateAverageBuy = (backtest, symbol, currentPrice, context) => {
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return Promise.resolve(strategy.validateAverageBuy(symbol, currentPrice));
+        };
         /**
          * Adds a new DCA entry to the active pending signal.
          *
@@ -12787,6 +13206,28 @@ class StrategyCoreService {
             }
             return await this.strategyConnectionService.clear(payload);
         };
+        /**
+         * Checks whether `partialProfit` would succeed without executing it.
+         * Validates context, then delegates to StrategyConnectionService.validatePartialProfit().
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param percentToClose - Percentage of position to check (0-100]
+         * @param currentPrice - Current market price to validate against
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if `partialProfit` would execute, false otherwise
+         */
+        this.validatePartialProfit = async (backtest, symbol, percentToClose, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService validatePartialProfit", {
+                symbol,
+                percentToClose,
+                currentPrice,
+                context,
+                backtest,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.validatePartialProfit(backtest, symbol, percentToClose, currentPrice, context);
+        };
         /**
          * Executes partial close at profit level (moving toward TP).
          *
@@ -12828,6 +13269,28 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.partialProfit(backtest, symbol, percentToClose, currentPrice, context);
         };
+        /**
+         * Checks whether `partialLoss` would succeed without executing it.
+         * Validates context, then delegates to StrategyConnectionService.validatePartialLoss().
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param percentToClose - Percentage of position to check (0-100]
+         * @param currentPrice - Current market price to validate against
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if `partialLoss` would execute, false otherwise
+         */
+        this.validatePartialLoss = async (backtest, symbol, percentToClose, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService validatePartialLoss", {
+                symbol,
+                percentToClose,
+                currentPrice,
+                context,
+                backtest,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.validatePartialLoss(backtest, symbol, percentToClose, currentPrice, context);
+        };
         /**
          * Executes partial close at loss level (moving toward SL).
          *
@@ -12897,6 +13360,28 @@ class StrategyCoreService {
          * );
          * ```
          */
+        this.validateTrailingStop = async (backtest, symbol, percentShift, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService validateTrailingStop", {
+                symbol,
+                percentShift,
+                currentPrice,
+                context,
+                backtest,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.validateTrailingStop(backtest, symbol, percentShift, currentPrice, context);
+        };
+        /**
+         * Checks whether `trailingStop` would succeed without executing it.
+         * Validates context, then delegates to StrategyConnectionService.validateTrailingStop().
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage shift of ORIGINAL SL distance [-100, 100], excluding 0
+         * @param currentPrice - Current market price to validate against
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if `trailingStop` would execute, false otherwise
+         */
         this.trailingStop = async (backtest, symbol, percentShift, currentPrice, context) => {
             this.loggerService.log("strategyCoreService trailingStop", {
                 symbol,
@@ -12932,6 +13417,28 @@ class StrategyCoreService {
          * );
          * ```
          */
+        this.validateTrailingTake = async (backtest, symbol, percentShift, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService validateTrailingTake", {
+                symbol,
+                percentShift,
+                currentPrice,
+                context,
+                backtest,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.validateTrailingTake(backtest, symbol, percentShift, currentPrice, context);
+        };
+        /**
+         * Checks whether `trailingTake` would succeed without executing it.
+         * Validates context, then delegates to StrategyConnectionService.validateTrailingTake().
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage adjustment to ORIGINAL TP distance [-100, 100], excluding 0
+         * @param currentPrice - Current market price to validate against
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if `trailingTake` would execute, false otherwise
+         */
         this.trailingTake = async (backtest, symbol, percentShift, currentPrice, context) => {
             this.loggerService.log("strategyCoreService trailingTake", {
                 symbol,
@@ -12963,6 +13470,26 @@ class StrategyCoreService {
          * );
          * ```
          */
+        this.validateBreakeven = async (backtest, symbol, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService validateBreakeven", {
+                symbol,
+                currentPrice,
+                context,
+                backtest,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.validateBreakeven(backtest, symbol, currentPrice, context);
+        };
+        /**
+         * Checks whether `breakeven` would succeed without executing it.
+         * Validates context, then delegates to StrategyConnectionService.validateBreakeven().
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price to validate against
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if `breakeven` would execute, false otherwise
+         */
         this.breakeven = async (backtest, symbol, currentPrice, context) => {
             this.loggerService.log("strategyCoreService breakeven", {
                 symbol,
@@ -13018,6 +13545,26 @@ class StrategyCoreService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise<boolean> - true if entry added, false if rejected
          */
+        this.validateAverageBuy = async (backtest, symbol, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService validateAverageBuy", {
+                symbol,
+                currentPrice,
+                context,
+                backtest,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.validateAverageBuy(backtest, symbol, currentPrice, context);
+        };
+        /**
+         * Checks whether `averageBuy` would succeed without executing it.
+         * Validates context, then delegates to StrategyConnectionService.validateAverageBuy().
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - New entry price to validate
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise<boolean> - true if `averageBuy` would execute, false otherwise
+         */
         this.averageBuy = async (backtest, symbol, currentPrice, context, cost) => {
             this.loggerService.log("strategyCoreService averageBuy", {
                 symbol,
@@ -30137,6 +30684,1026 @@ const investedCostToPercent = (dollarAmount, investedCost) => {
     return (dollarAmount / investedCost) * 100;
 };
 
+/**
+ * Convert an absolute stop-loss price to a percentShift for `commitTrailingStop`.
+ *
+ * percentShift = newSlDistancePercent - originalSlDistancePercent
+ * where distance = Math.abs((effectivePriceOpen - slPrice) / effectivePriceOpen * 100)
+ *
+ * @param newStopLossPrice - Desired absolute stop-loss price
+ * @param originalStopLossPrice - Original stop-loss price from the pending signal
+ * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @returns percentShift to pass to `commitTrailingStop`
+ *
+ * @example
+ * // LONG: entry=100, originalSL=90, desired newSL=95
+ * const shift = slPriceToPercentShift(95, 90, 100); // -5
+ * await commitTrailingStop("BTCUSDT", shift, currentPrice);
+ */
+const slPriceToPercentShift = (newStopLossPrice, originalStopLossPrice, effectivePriceOpen) => {
+    const originalSlDistancePercent = Math.abs((effectivePriceOpen - originalStopLossPrice) / effectivePriceOpen * 100);
+    const newSlDistancePercent = Math.abs((effectivePriceOpen - newStopLossPrice) / effectivePriceOpen * 100);
+    return newSlDistancePercent - originalSlDistancePercent;
+};
+
+/**
+ * Convert an absolute take-profit price to a percentShift for `commitTrailingTake`.
+ *
+ * percentShift = newTpDistancePercent - originalTpDistancePercent
+ * where distance = Math.abs((tpPrice - effectivePriceOpen) / effectivePriceOpen * 100)
+ *
+ * @param newTakeProfitPrice - Desired absolute take-profit price
+ * @param originalTakeProfitPrice - Original take-profit price from the pending signal
+ * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @returns percentShift to pass to `commitTrailingTake`
+ *
+ * @example
+ * // LONG: entry=100, originalTP=110, desired newTP=107
+ * const shift = tpPriceToPercentShift(107, 110, 100); // -3
+ * await commitTrailingTake("BTCUSDT", shift, currentPrice);
+ */
+const tpPriceToPercentShift = (newTakeProfitPrice, originalTakeProfitPrice, effectivePriceOpen) => {
+    const originalTpDistancePercent = Math.abs((originalTakeProfitPrice - effectivePriceOpen) / effectivePriceOpen * 100);
+    const newTpDistancePercent = Math.abs((newTakeProfitPrice - effectivePriceOpen) / effectivePriceOpen * 100);
+    return newTpDistancePercent - originalTpDistancePercent;
+};
+
+/**
+ * Convert a percentShift for `commitTrailingStop` back to an absolute stop-loss price.
+ *
+ * Inverse of `slPriceToPercentShift`.
+ *
+ * newSlDistancePercent = originalSlDistancePercent + percentShift
+ * LONG:  newStopLossPrice = effectivePriceOpen * (1 - newSlDistancePercent / 100)
+ * SHORT: newStopLossPrice = effectivePriceOpen * (1 + newSlDistancePercent / 100)
+ *
+ * @param percentShift - Value returned by `slPriceToPercentShift` (or passed to `commitTrailingStop`)
+ * @param originalStopLossPrice - Original stop-loss price from the pending signal
+ * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @param position - Position direction: "long" or "short"
+ * @returns Absolute stop-loss price corresponding to the given percentShift
+ *
+ * @example
+ * // LONG: entry=100, originalSL=90, percentShift=-5
+ * const price = slPercentShiftToPrice(-5, 90, 100, "long"); // 95
+ */
+const slPercentShiftToPrice = (percentShift, originalStopLossPrice, effectivePriceOpen, position) => {
+    const originalSlDistancePercent = Math.abs((effectivePriceOpen - originalStopLossPrice) / effectivePriceOpen * 100);
+    const newSlDistancePercent = originalSlDistancePercent + percentShift;
+    return position === "long"
+        ? effectivePriceOpen * (1 - newSlDistancePercent / 100)
+        : effectivePriceOpen * (1 + newSlDistancePercent / 100);
+};
+
+/**
+ * Convert a percentShift for `commitTrailingTake` back to an absolute take-profit price.
+ *
+ * Inverse of `tpPriceToPercentShift`.
+ *
+ * newTpDistancePercent = originalTpDistancePercent + percentShift
+ * LONG:  newTakeProfitPrice = effectivePriceOpen * (1 + newTpDistancePercent / 100)
+ * SHORT: newTakeProfitPrice = effectivePriceOpen * (1 - newTpDistancePercent / 100)
+ *
+ * @param percentShift - Value returned by `tpPriceToPercentShift` (or passed to `commitTrailingTake`)
+ * @param originalTakeProfitPrice - Original take-profit price from the pending signal
+ * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @param position - Position direction: "long" or "short"
+ * @returns Absolute take-profit price corresponding to the given percentShift
+ *
+ * @example
+ * // LONG: entry=100, originalTP=110, percentShift=-3
+ * const price = tpPercentShiftToPrice(-3, 110, 100, "long"); // 107
+ */
+const tpPercentShiftToPrice = (percentShift, originalTakeProfitPrice, effectivePriceOpen, position) => {
+    const originalTpDistancePercent = Math.abs((originalTakeProfitPrice - effectivePriceOpen) / effectivePriceOpen * 100);
+    const newTpDistancePercent = originalTpDistancePercent + percentShift;
+    return position === "long"
+        ? effectivePriceOpen * (1 + newTpDistancePercent / 100)
+        : effectivePriceOpen * (1 - newTpDistancePercent / 100);
+};
+
+/**
+ * Compute the dollar cost of a partial close from percentToClose and current invested cost basis.
+ *
+ * cost = (percentToClose / 100) * investedCost
+ *
+ * @param percentToClose - Percentage of position to close (0–100)
+ * @param investedCost - Current invested cost basis (from `getPositionInvestedCost`)
+ * @returns Dollar amount that will be closed
+ *
+ * @example
+ * // Position investedCost=$1000, closing 25%
+ * const cost = percentToCloseCost(25, 1000); // 250
+ */
+const percentToCloseCost = (percentToClose, investedCost) => {
+    return (percentToClose / 100) * investedCost;
+};
+
+/**
+ * Compute the new stop-loss price for a breakeven operation.
+ *
+ * Breakeven moves the SL to the effective entry price (effectivePriceOpen).
+ * The value is the same regardless of position direction.
+ *
+ * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @returns New stop-loss price equal to the effective entry price
+ *
+ * @example
+ * // LONG: entry=100, SL was 90 → breakeven SL = 100
+ * const newSL = breakevenNewStopLossPrice(100); // 100
+ *
+ * // SHORT: entry=100, SL was 110 → breakeven SL = 100
+ * const newSL = breakevenNewStopLossPrice(100); // 100
+ */
+const breakevenNewStopLossPrice = (effectivePriceOpen) => {
+    return effectivePriceOpen;
+};
+
+/**
+ * Compute the effective take-profit price for a breakeven operation.
+ *
+ * Breakeven does not change the take-profit. Returns the currently effective TP:
+ * `_trailingPriceTakeProfit` if set (trailing TP active), otherwise `priceTakeProfit`.
+ *
+ * @param priceTakeProfit - Original take-profit price from the pending signal
+ * @param trailingPriceTakeProfit - Trailing take-profit override, or undefined if not set
+ * @returns Effective take-profit price (unchanged by breakeven)
+ *
+ * @example
+ * // No trailing TP set
+ * const newTP = breakevenNewTakeProfitPrice(110, undefined); // 110
+ *
+ * // Trailing TP active
+ * const newTP = breakevenNewTakeProfitPrice(110, 107); // 107
+ */
+const breakevenNewTakeProfitPrice = (priceTakeProfit, trailingPriceTakeProfit) => {
+    return trailingPriceTakeProfit ?? priceTakeProfit;
+};
+
+const BROKER_METHOD_NAME_COMMIT_SIGNAL_OPEN = "BrokerAdapter.commitSignalOpen";
+const BROKER_METHOD_NAME_COMMIT_SIGNAL_CLOSE = "BrokerAdapter.commitSignalClose";
+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";
+const BROKER_METHOD_NAME_COMMIT_TRAILING_TAKE = "BrokerAdapter.commitTrailingTake";
+const BROKER_METHOD_NAME_COMMIT_BREAKEVEN = "BrokerAdapter.commitBreakeven";
+const BROKER_METHOD_NAME_COMMIT_AVERAGE_BUY = "BrokerAdapter.commitAverageBuy";
+const BROKER_METHOD_NAME_USE_BROKER_ADAPTER = "BrokerAdapter.useBrokerAdapter";
+const BROKER_METHOD_NAME_ENABLE = "BrokerAdapter.enable";
+const BROKER_METHOD_NAME_DISABLE = "BrokerAdapter.disable";
+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_PARTIAL_PROFIT = "BrokerBase.onPartialProfitCommit";
+const BROKER_BASE_METHOD_NAME_ON_PARTIAL_LOSS = "BrokerBase.onPartialLossCommit";
+const BROKER_BASE_METHOD_NAME_ON_TRAILING_STOP = "BrokerBase.onTrailingStopCommit";
+const BROKER_BASE_METHOD_NAME_ON_TRAILING_TAKE = "BrokerBase.onTrailingTakeCommit";
+const BROKER_BASE_METHOD_NAME_ON_BREAKEVEN = "BrokerBase.onBreakevenCommit";
+const BROKER_BASE_METHOD_NAME_ON_AVERAGE_BUY = "BrokerBase.onAverageBuyCommit";
+class BrokerProxy {
+    constructor(_instance) {
+        this._instance = _instance;
+        this.waitForInit = singleshot(async () => {
+            if (this._instance.waitForInit) {
+                await this._instance.waitForInit();
+            }
+        });
+    }
+    async onSignalOpenCommit(payload) {
+        if (this._instance.onSignalOpenCommit) {
+            await this._instance.onSignalOpenCommit(payload);
+        }
+    }
+    async onSignalCloseCommit(payload) {
+        if (this._instance.onSignalCloseCommit) {
+            await this._instance.onSignalCloseCommit(payload);
+        }
+    }
+    async onPartialProfitCommit(payload) {
+        if (this._instance.onPartialProfitCommit) {
+            await this._instance.onPartialProfitCommit(payload);
+        }
+    }
+    async onPartialLossCommit(payload) {
+        if (this._instance.onPartialLossCommit) {
+            await this._instance.onPartialLossCommit(payload);
+        }
+    }
+    async onTrailingStopCommit(payload) {
+        if (this._instance.onTrailingStopCommit) {
+            await this._instance.onTrailingStopCommit(payload);
+        }
+    }
+    async onTrailingTakeCommit(payload) {
+        if (this._instance.onTrailingTakeCommit) {
+            await this._instance.onTrailingTakeCommit(payload);
+        }
+    }
+    async onBreakevenCommit(payload) {
+        if (this._instance.onBreakevenCommit) {
+            await this._instance.onBreakevenCommit(payload);
+        }
+    }
+    async onAverageBuyCommit(payload) {
+        if (this._instance.onAverageBuyCommit) {
+            await this._instance.onAverageBuyCommit(payload);
+        }
+    }
+}
+/**
+ * Facade for broker integration — intercepts all commit* operations before DI-core mutations.
+ *
+ * Acts as a transaction control point: if any commit* method throws, the DI-core mutation
+ * is never reached and the state remains unchanged.
+ *
+ * In backtest mode all commit* calls are silently skipped (payload.backtest === true).
+ * In live mode the call is forwarded to the registered IBroker adapter via BrokerProxy.
+ *
+ * signal-open and signal-close events are routed automatically via syncSubject subscription
+ * (activated on `enable()`). All other commit* methods are called explicitly from
+ * Live.ts / Backtest.ts / strategy.ts before the corresponding strategyCoreService call.
+ *
+ * @example
+ * ```typescript
+ * import { Broker } from "backtest-kit";
+ *
+ * // Register a custom broker adapter
+ * Broker.useBrokerAdapter(MyBrokerAdapter);
+ *
+ * // Activate syncSubject subscription (signal-open / signal-close routing)
+ * const dispose = Broker.enable();
+ *
+ * // ... run strategy ...
+ *
+ * // Deactivate when done
+ * Broker.disable();
+ * ```
+ */
+class BrokerAdapter {
+    constructor() {
+        this._brokerInstance = null;
+        /**
+         * Forwards a signal-open event to the registered broker adapter.
+         *
+         * Called automatically via syncSubject when `enable()` is active.
+         * Skipped silently in backtest mode or when no adapter is registered.
+         *
+         * @param payload - Signal open details: symbol, cost, position, prices, context, backtest flag
+         *
+         * @example
+         * ```typescript
+         * await Broker.commitSignalOpen({
+         *   symbol: "BTCUSDT",
+         *   cost: 100,
+         *   position: "long",
+         *   priceOpen: 50000,
+         *   priceTakeProfit: 55000,
+         *   priceStopLoss: 48000,
+         *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+         *   backtest: false,
+         * });
+         * ```
+         */
+        this.commitSignalOpen = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_SIGNAL_OPEN, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            await this._brokerInstance?.onSignalOpenCommit(payload);
+        };
+        /**
+         * Forwards a signal-close event to the registered broker adapter.
+         *
+         * Called automatically via syncSubject when `enable()` is active.
+         * Skipped silently in backtest mode or when no adapter is registered.
+         *
+         * @param payload - Signal close details: symbol, cost, position, currentPrice, pnl, context, backtest flag
+         *
+         * @example
+         * ```typescript
+         * await Broker.commitSignalClose({
+         *   symbol: "BTCUSDT",
+         *   cost: 100,
+         *   position: "long",
+         *   currentPrice: 54000,
+         *   priceTakeProfit: 55000,
+         *   priceStopLoss: 48000,
+         *   totalEntries: 2,
+         *   totalPartials: 1,
+         *   pnl: { profit: 80, loss: 0, volume: 100 },
+         *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+         *   backtest: false,
+         * });
+         * ```
+         */
+        this.commitSignalClose = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_SIGNAL_CLOSE, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            await this._brokerInstance?.onSignalCloseCommit(payload);
+        };
+        /**
+         * Intercepts a partial-profit close before DI-core mutation.
+         *
+         * Called explicitly from Live.ts / Backtest.ts / strategy.ts after all validations pass,
+         * but before `strategyCoreService.partialProfit()`. If this method throws, the DI mutation
+         * is skipped and state remains unchanged.
+         *
+         * Skipped silently in backtest mode or when no adapter is registered.
+         *
+         * @param payload - Partial profit details: symbol, percentToClose, cost (dollar value), currentPrice, context, backtest flag
+         *
+         * @example
+         * ```typescript
+         * await Broker.commitPartialProfit({
+         *   symbol: "BTCUSDT",
+         *   percentToClose: 30,
+         *   cost: 30,
+         *   currentPrice: 52000,
+         *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+         *   backtest: false,
+         * });
+         * ```
+         */
+        this.commitPartialProfit = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_PARTIAL_PROFIT, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            await this._brokerInstance?.onPartialProfitCommit(payload);
+        };
+        /**
+         * Intercepts a partial-loss close before DI-core mutation.
+         *
+         * Called explicitly from Live.ts / Backtest.ts / strategy.ts after all validations pass,
+         * but before `strategyCoreService.partialLoss()`. If this method throws, the DI mutation
+         * is skipped and state remains unchanged.
+         *
+         * Skipped silently in backtest mode or when no adapter is registered.
+         *
+         * @param payload - Partial loss details: symbol, percentToClose, cost (dollar value), currentPrice, context, backtest flag
+         *
+         * @example
+         * ```typescript
+         * await Broker.commitPartialLoss({
+         *   symbol: "BTCUSDT",
+         *   percentToClose: 40,
+         *   cost: 40,
+         *   currentPrice: 48500,
+         *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+         *   backtest: false,
+         * });
+         * ```
+         */
+        this.commitPartialLoss = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_PARTIAL_LOSS, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            await this._brokerInstance?.onPartialLossCommit(payload);
+        };
+        /**
+         * Intercepts a trailing stop-loss update before DI-core mutation.
+         *
+         * Called explicitly after all validations pass, but before `strategyCoreService.trailingStop()`.
+         * `newStopLossPrice` is the absolute price computed from percentShift + original SL + effectivePriceOpen.
+         *
+         * Skipped silently in backtest mode or when no adapter is registered.
+         *
+         * @param payload - Trailing stop details: symbol, percentShift, currentPrice, newStopLossPrice, context, backtest flag
+         *
+         * @example
+         * ```typescript
+         * // LONG: entry=100, originalSL=90, percentShift=-5 → newSL=95
+         * await Broker.commitTrailingStop({
+         *   symbol: "BTCUSDT",
+         *   percentShift: -5,
+         *   currentPrice: 102,
+         *   newStopLossPrice: 95,
+         *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+         *   backtest: false,
+         * });
+         * ```
+         */
+        this.commitTrailingStop = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_TRAILING_STOP, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            await this._brokerInstance?.onTrailingStopCommit(payload);
+        };
+        /**
+         * Intercepts a trailing take-profit update before DI-core mutation.
+         *
+         * Called explicitly after all validations pass, but before `strategyCoreService.trailingTake()`.
+         * `newTakeProfitPrice` is the absolute price computed from percentShift + original TP + effectivePriceOpen.
+         *
+         * Skipped silently in backtest mode or when no adapter is registered.
+         *
+         * @param payload - Trailing take details: symbol, percentShift, currentPrice, newTakeProfitPrice, context, backtest flag
+         *
+         * @example
+         * ```typescript
+         * // LONG: entry=100, originalTP=110, percentShift=-3 → newTP=107
+         * await Broker.commitTrailingTake({
+         *   symbol: "BTCUSDT",
+         *   percentShift: -3,
+         *   currentPrice: 102,
+         *   newTakeProfitPrice: 107,
+         *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+         *   backtest: false,
+         * });
+         * ```
+         */
+        this.commitTrailingTake = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_TRAILING_TAKE, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            await this._brokerInstance?.onTrailingTakeCommit(payload);
+        };
+        /**
+         * Intercepts a breakeven operation before DI-core mutation.
+         *
+         * Called explicitly after all validations pass, but before `strategyCoreService.breakeven()`.
+         * `newStopLossPrice` equals effectivePriceOpen (entry price).
+         * `newTakeProfitPrice` equals `_trailingPriceTakeProfit ?? priceTakeProfit` (TP is unchanged by breakeven).
+         *
+         * Skipped silently in backtest mode or when no adapter is registered.
+         *
+         * @param payload - Breakeven details: symbol, currentPrice, newStopLossPrice, newTakeProfitPrice, context, backtest flag
+         *
+         * @example
+         * ```typescript
+         * // LONG: entry=100, currentPrice=100.5, newSL=100 (entry), newTP=110 (unchanged)
+         * await Broker.commitBreakeven({
+         *   symbol: "BTCUSDT",
+         *   currentPrice: 100.5,
+         *   newStopLossPrice: 100,
+         *   newTakeProfitPrice: 110,
+         *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+         *   backtest: false,
+         * });
+         * ```
+         */
+        this.commitBreakeven = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_BREAKEVEN, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            await this._brokerInstance?.onBreakevenCommit(payload);
+        };
+        /**
+         * Intercepts a DCA average-buy entry before DI-core mutation.
+         *
+         * Called explicitly after all validations pass, but before `strategyCoreService.averageBuy()`.
+         * `currentPrice` is the market price at which the new DCA entry is added.
+         * `cost` is the dollar amount of the new entry (default: CC_POSITION_ENTRY_COST).
+         *
+         * Skipped silently in backtest mode or when no adapter is registered.
+         *
+         * @param payload - Average buy details: symbol, currentPrice, cost, context, backtest flag
+         *
+         * @example
+         * ```typescript
+         * // Add DCA entry at current market price
+         * await Broker.commitAverageBuy({
+         *   symbol: "BTCUSDT",
+         *   currentPrice: 42000,
+         *   cost: 100,
+         *   context: { strategyName: "my-strategy", exchangeName: "binance", frameName: "1h" },
+         *   backtest: false,
+         * });
+         * ```
+         */
+        this.commitAverageBuy = async (payload) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_COMMIT_AVERAGE_BUY, {
+                symbol: payload.symbol,
+                context: payload.context,
+            });
+            if (!this.enable.hasValue()) {
+                return;
+            }
+            if (payload.backtest) {
+                return;
+            }
+            await this._brokerInstance?.onAverageBuyCommit(payload);
+        };
+        /**
+         * Registers a broker adapter instance or constructor to receive commit* callbacks.
+         *
+         * Must be called before `enable()`. Accepts either a class constructor (called with `new`)
+         * or an already-instantiated object implementing `Partial<IBroker>`.
+         *
+         * @param broker - IBroker constructor or instance
+         *
+         * @example
+         * ```typescript
+         * import { Broker } from "backtest-kit";
+         *
+         * // Register via constructor
+         * Broker.useBrokerAdapter(MyBrokerAdapter);
+         *
+         * // Register via instance
+         * Broker.useBrokerAdapter(new MyBrokerAdapter());
+         * ```
+         */
+        this.useBrokerAdapter = (broker) => {
+            bt.loggerService.info(BROKER_METHOD_NAME_USE_BROKER_ADAPTER, {});
+            if (typeof broker === "function") {
+                const instance = Reflect.construct(broker, []);
+                this._brokerInstance = new BrokerProxy(instance);
+                return;
+            }
+            this._brokerInstance = new BrokerProxy(broker);
+        };
+        /**
+         * Activates the broker: subscribes to syncSubject for signal-open / signal-close routing.
+         *
+         * Must be called after `useBrokerAdapter()`. Returns a dispose function that unsubscribes
+         * from syncSubject (equivalent to calling `disable()`).
+         *
+         * Calling `enable()` without a registered adapter throws immediately.
+         * Calling `enable()` more than once is idempotent (singleshot guard).
+         *
+         * @returns Dispose function — call it to deactivate the broker subscription
+         *
+         * @example
+         * ```typescript
+         * import { Broker } from "backtest-kit";
+         *
+         * Broker.useBrokerAdapter(MyBrokerAdapter);
+         * const dispose = Broker.enable();
+         *
+         * // ... run backtest or live session ...
+         *
+         * dispose(); // or Broker.disable()
+         * ```
+         */
+        this.enable = singleshot(() => {
+            bt.loggerService.info(BROKER_METHOD_NAME_ENABLE, {});
+            if (!this._brokerInstance) {
+                this.enable.clear();
+                throw new Error("No broker instance provided. Call Broker.useBrokerAdapter first.");
+            }
+            const unSignalOpen = syncSubject.subscribe(async (event) => {
+                if (event.action !== "signal-open") {
+                    return;
+                }
+                await this.commitSignalOpen({
+                    position: event.signal.position,
+                    cost: event.signal.cost,
+                    symbol: event.symbol,
+                    priceTakeProfit: event.signal.priceTakeProfit,
+                    priceStopLoss: event.signal.priceStopLoss,
+                    priceOpen: event.signal.priceOpen,
+                    context: {
+                        strategyName: event.strategyName,
+                        exchangeName: event.exchangeName,
+                        frameName: event.frameName,
+                    },
+                    backtest: event.backtest,
+                });
+            });
+            const unSignalClose = syncSubject.subscribe(async (event) => {
+                if (event.action !== "signal-close") {
+                    return;
+                }
+                await this.commitSignalClose({
+                    position: event.signal.position,
+                    currentPrice: event.currentPrice,
+                    cost: event.signal.cost,
+                    symbol: event.symbol,
+                    pnl: event.pnl,
+                    totalEntries: event.totalEntries,
+                    totalPartials: event.totalPartials,
+                    priceStopLoss: event.signal.priceStopLoss,
+                    priceTakeProfit: event.signal.priceTakeProfit,
+                    context: {
+                        strategyName: event.strategyName,
+                        exchangeName: event.exchangeName,
+                        frameName: event.frameName,
+                    },
+                    backtest: event.backtest,
+                });
+            });
+            const disposeFn = compose(() => unSignalOpen(), () => unSignalClose());
+            return () => {
+                this.enable.clear();
+                disposeFn();
+            };
+        });
+        /**
+         * Deactivates the broker: unsubscribes from syncSubject and resets the singleshot guard.
+         *
+         * Idempotent — safe to call even if `enable()` was never called.
+         * After `disable()`, `enable()` can be called again to reactivate.
+         *
+         * @example
+         * ```typescript
+         * import { Broker } from "backtest-kit";
+         *
+         * Broker.useBrokerAdapter(MyBrokerAdapter);
+         * Broker.enable();
+         *
+         * // Stop receiving events
+         * Broker.disable();
+         * ```
+         */
+        this.disable = () => {
+            bt.loggerService.info(BROKER_METHOD_NAME_DISABLE, {});
+            if (this.enable.hasValue()) {
+                const lastSubscription = this.enable();
+                lastSubscription();
+            }
+        };
+    }
+}
+/**
+ * Base class for custom broker adapter implementations.
+ *
+ * Provides default no-op implementations for all IBroker methods that log events.
+ * Extend this class to implement a real exchange adapter for:
+ * - Placing and canceling limit/market orders
+ * - Updating stop-loss and take-profit levels on exchange
+ * - Tracking position state in an external system
+ * - Sending trade notifications (Telegram, Discord, Email)
+ * - Recording trades to a database or analytics service
+ *
+ * Key features:
+ * - All methods have default implementations (no need to override unused methods)
+ * - Automatic logging of all events via bt.loggerService
+ * - Implements the full IBroker interface
+ * - `makeExtendable` applied for correct subclass instantiation
+ *
+ * Lifecycle:
+ * 1. Constructor called (no arguments)
+ * 2. `waitForInit()` called once for async initialization (e.g. exchange login)
+ * 3. Event methods called as strategy executes
+ * 4. No explicit dispose — clean up in `waitForInit` teardown or externally
+ *
+ * Event flow (called only in live mode, skipped in backtest):
+ * - `onSignalOpenCommit` — new position opened
+ * - `onSignalCloseCommit` — position closed (SL/TP hit or manual close)
+ * - `onPartialProfitCommit` — partial close at profit executed
+ * - `onPartialLossCommit` — partial close at loss executed
+ * - `onTrailingStopCommit` — trailing stop-loss updated
+ * - `onTrailingTakeCommit` — trailing take-profit updated
+ * - `onBreakevenCommit` — stop-loss moved to entry price
+ * - `onAverageBuyCommit` — new DCA entry added to position
+ *
+ * @example
+ * ```typescript
+ * import { BrokerBase, Broker } from "backtest-kit";
+ *
+ * // Extend BrokerBase and override only needed methods
+ * class BinanceBroker extends BrokerBase {
+ *   private client: BinanceClient | null = null;
+ *
+ *   async waitForInit() {
+ *     super.waitForInit(); // Call parent for logging
+ *     this.client = new BinanceClient(process.env.API_KEY, process.env.SECRET);
+ *     await this.client.connect();
+ *   }
+ *
+ *   async onSignalOpenCommit(payload: BrokerSignalOpenPayload) {
+ *     super.onSignalOpenCommit(payload); // Call parent for logging
+ *     await this.client!.placeOrder({
+ *       symbol: payload.symbol,
+ *       side: payload.position === "long" ? "BUY" : "SELL",
+ *       quantity: payload.cost / payload.priceOpen,
+ *     });
+ *   }
+ *
+ *   async onSignalCloseCommit(payload: BrokerSignalClosePayload) {
+ *     super.onSignalCloseCommit(payload); // Call parent for logging
+ *     await this.client!.closePosition(payload.symbol);
+ *   }
+ * }
+ *
+ * // Register the adapter
+ * Broker.useBrokerAdapter(BinanceBroker);
+ * Broker.enable();
+ * ```
+ *
+ * @example
+ * ```typescript
+ * // Minimal implementation — only handle opens and closes
+ * class NotifyBroker extends BrokerBase {
+ *   async onSignalOpenCommit(payload: BrokerSignalOpenPayload) {
+ *     await sendTelegram(`Opened ${payload.position} on ${payload.symbol}`);
+ *   }
+ *
+ *   async onSignalCloseCommit(payload: BrokerSignalClosePayload) {
+ *     const pnl = payload.pnl.profit - payload.pnl.loss;
+ *     await sendTelegram(`Closed ${payload.symbol}: PnL $${pnl.toFixed(2)}`);
+ *   }
+ * }
+ * ```
+ */
+class BrokerBase {
+    /**
+     * Performs async initialization before the broker starts receiving events.
+     *
+     * Called once by BrokerProxy via `waitForInit()` (singleshot) before the first event.
+     * Override to establish exchange connections, authenticate API clients, load configuration.
+     *
+     * Default implementation: Logs initialization event.
+     *
+     * @example
+     * ```typescript
+     * async waitForInit() {
+     *   super.waitForInit(); // Keep parent logging
+     *   this.exchange = new ExchangeClient(process.env.API_KEY);
+     *   await this.exchange.authenticate();
+     * }
+     * ```
+     */
+    async waitForInit() {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_WAIT_FOR_INIT, {});
+    }
+    /**
+     * Called when a new position is 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.
+     *
+     * @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({
+     *     symbol: payload.symbol,
+     *     side: payload.position === "long" ? "BUY" : "SELL",
+     *     quantity: payload.cost / payload.priceOpen,
+     *   });
+     * }
+     * ```
+     */
+    async onSignalOpenCommit(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_SIGNAL_OPEN, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+    /**
+     * Called when a position is fully 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.
+     *
+     * @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);
+     *   await this.db.recordTrade({ symbol: payload.symbol, pnl: payload.pnl });
+     * }
+     * ```
+     */
+    async onSignalCloseCommit(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_SIGNAL_CLOSE, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+    /**
+     * Called when a partial close at profit is executed.
+     *
+     * Triggered explicitly from strategy.ts / Live.ts / Backtest.ts after all validations pass,
+     * before `strategyCoreService.partialProfit()`. If this method throws, the DI mutation is skipped.
+     * Use to partially close the position on the exchange at the profit level.
+     *
+     * Default implementation: Logs partial profit event.
+     *
+     * @param payload - Partial profit details: symbol, percentToClose, cost (dollar value), currentPrice, context, backtest
+     *
+     * @example
+     * ```typescript
+     * async onPartialProfitCommit(payload: BrokerPartialProfitPayload) {
+     *   super.onPartialProfitCommit(payload); // Keep parent logging
+     *   await this.exchange.reducePosition({
+     *     symbol: payload.symbol,
+     *     dollarAmount: payload.cost,
+     *     price: payload.currentPrice,
+     *   });
+     * }
+     * ```
+     */
+    async onPartialProfitCommit(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_PARTIAL_PROFIT, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+    /**
+     * Called when a partial close at loss is executed.
+     *
+     * Triggered explicitly from strategy.ts / Live.ts / Backtest.ts after all validations pass,
+     * before `strategyCoreService.partialLoss()`. If this method throws, the DI mutation is skipped.
+     * Use to partially close the position on the exchange at the loss level.
+     *
+     * Default implementation: Logs partial loss event.
+     *
+     * @param payload - Partial loss details: symbol, percentToClose, cost (dollar value), currentPrice, context, backtest
+     *
+     * @example
+     * ```typescript
+     * async onPartialLossCommit(payload: BrokerPartialLossPayload) {
+     *   super.onPartialLossCommit(payload); // Keep parent logging
+     *   await this.exchange.reducePosition({
+     *     symbol: payload.symbol,
+     *     dollarAmount: payload.cost,
+     *     price: payload.currentPrice,
+     *   });
+     * }
+     * ```
+     */
+    async onPartialLossCommit(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_PARTIAL_LOSS, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+    /**
+     * Called when the trailing stop-loss level is updated.
+     *
+     * Triggered explicitly after all validations pass, before `strategyCoreService.trailingStop()`.
+     * `newStopLossPrice` is the absolute SL price — use it to update the exchange order directly.
+     *
+     * Default implementation: Logs trailing stop event.
+     *
+     * @param payload - Trailing stop details: symbol, percentShift, currentPrice, newStopLossPrice, context, backtest
+     *
+     * @example
+     * ```typescript
+     * async onTrailingStopCommit(payload: BrokerTrailingStopPayload) {
+     *   super.onTrailingStopCommit(payload); // Keep parent logging
+     *   await this.exchange.updateStopLoss({
+     *     symbol: payload.symbol,
+     *     price: payload.newStopLossPrice,
+     *   });
+     * }
+     * ```
+     */
+    async onTrailingStopCommit(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_TRAILING_STOP, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+    /**
+     * Called when the trailing take-profit level is updated.
+     *
+     * Triggered explicitly after all validations pass, before `strategyCoreService.trailingTake()`.
+     * `newTakeProfitPrice` is the absolute TP price — use it to update the exchange order directly.
+     *
+     * Default implementation: Logs trailing take event.
+     *
+     * @param payload - Trailing take details: symbol, percentShift, currentPrice, newTakeProfitPrice, context, backtest
+     *
+     * @example
+     * ```typescript
+     * async onTrailingTakeCommit(payload: BrokerTrailingTakePayload) {
+     *   super.onTrailingTakeCommit(payload); // Keep parent logging
+     *   await this.exchange.updateTakeProfit({
+     *     symbol: payload.symbol,
+     *     price: payload.newTakeProfitPrice,
+     *   });
+     * }
+     * ```
+     */
+    async onTrailingTakeCommit(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_TRAILING_TAKE, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+    /**
+     * Called when the stop-loss is moved to breakeven (entry price).
+     *
+     * Triggered explicitly after all validations pass, before `strategyCoreService.breakeven()`.
+     * `newStopLossPrice` equals `effectivePriceOpen` — the position's effective entry price.
+     * `newTakeProfitPrice` is unchanged by breakeven.
+     *
+     * Default implementation: Logs breakeven event.
+     *
+     * @param payload - Breakeven details: symbol, currentPrice, newStopLossPrice, newTakeProfitPrice, context, backtest
+     *
+     * @example
+     * ```typescript
+     * async onBreakevenCommit(payload: BrokerBreakevenPayload) {
+     *   super.onBreakevenCommit(payload); // Keep parent logging
+     *   await this.exchange.updateStopLoss({
+     *     symbol: payload.symbol,
+     *     price: payload.newStopLossPrice, // = entry price
+     *   });
+     * }
+     * ```
+     */
+    async onBreakevenCommit(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_BREAKEVEN, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+    /**
+     * Called when a new DCA entry is added to the active position.
+     *
+     * Triggered explicitly after all validations pass, before `strategyCoreService.averageBuy()`.
+     * `currentPrice` is the market price at which the new averaging entry is placed.
+     * `cost` is the dollar amount of the new DCA entry.
+     *
+     * Default implementation: Logs average buy event.
+     *
+     * @param payload - Average buy details: symbol, currentPrice, cost, context, backtest
+     *
+     * @example
+     * ```typescript
+     * async onAverageBuyCommit(payload: BrokerAverageBuyPayload) {
+     *   super.onAverageBuyCommit(payload); // Keep parent logging
+     *   await this.exchange.placeMarketOrder({
+     *     symbol: payload.symbol,
+     *     side: "BUY",
+     *     quantity: payload.cost / payload.currentPrice,
+     *   });
+     * }
+     * ```
+     */
+    async onAverageBuyCommit(payload) {
+        bt.loggerService.info(BROKER_BASE_METHOD_NAME_ON_AVERAGE_BUY, {
+            symbol: payload.symbol,
+            context: payload.context,
+        });
+    }
+}
+// @ts-ignore
+BrokerBase = makeExtendable(BrokerBase);
+/**
+ * Global singleton instance of BrokerAdapter.
+ * Provides static-like access to all broker commit methods and lifecycle controls.
+ *
+ * @example
+ * ```typescript
+ * import { Broker } from "backtest-kit";
+ *
+ * Broker.useBrokerAdapter(MyBrokerAdapter);
+ * const dispose = Broker.enable();
+ * ```
+ */
+const Broker = new BrokerAdapter();
+
 const CANCEL_SCHEDULED_METHOD_NAME = "strategy.commitCancelScheduled";
 const CLOSE_PENDING_METHOD_NAME = "strategy.commitClosePending";
 const PARTIAL_PROFIT_METHOD_NAME = "strategy.commitPartialProfit";
@@ -30145,6 +31712,8 @@ const PARTIAL_PROFIT_COST_METHOD_NAME = "strategy.commitPartialProfitCost";
 const PARTIAL_LOSS_COST_METHOD_NAME = "strategy.commitPartialLossCost";
 const TRAILING_STOP_METHOD_NAME = "strategy.commitTrailingStop";
 const TRAILING_PROFIT_METHOD_NAME = "strategy.commitTrailingTake";
+const TRAILING_STOP_COST_METHOD_NAME = "strategy.commitTrailingStopCost";
+const TRAILING_PROFIT_COST_METHOD_NAME = "strategy.commitTrailingTakeCost";
 const BREAKEVEN_METHOD_NAME = "strategy.commitBreakeven";
 const ACTIVATE_SCHEDULED_METHOD_NAME = "strategy.commitActivateScheduled";
 const AVERAGE_BUY_METHOD_NAME = "strategy.commitAverageBuy";
@@ -30274,6 +31843,28 @@ async function commitPartialProfit(symbol, percentToClose) {
     const currentPrice = await getAveragePrice(symbol);
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    const investedCostForProfit = await bt.strategyCoreService.getPositionInvestedCost(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    if (investedCostForProfit === null) {
+        return false;
+    }
+    const signalForProfit = await bt.strategyCoreService.getPendingSignal(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+    if (!signalForProfit) {
+        return false;
+    }
+    if (await not(bt.strategyCoreService.validatePartialProfit(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName }))) {
+        return false;
+    }
+    await Broker.commitPartialProfit({
+        symbol,
+        percentToClose,
+        cost: percentToCloseCost(percentToClose, investedCostForProfit),
+        currentPrice,
+        position: signalForProfit.position,
+        priceTakeProfit: signalForProfit.priceTakeProfit,
+        priceStopLoss: signalForProfit.priceStopLoss,
+        context: { exchangeName, frameName, strategyName },
+        backtest: isBacktest,
+    });
     return await bt.strategyCoreService.partialProfit(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
 }
 /**
@@ -30317,6 +31908,28 @@ async function commitPartialLoss(symbol, percentToClose) {
     const currentPrice = await getAveragePrice(symbol);
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    const investedCostForLoss = await bt.strategyCoreService.getPositionInvestedCost(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    if (investedCostForLoss === null) {
+        return false;
+    }
+    const signalForLoss = await bt.strategyCoreService.getPendingSignal(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+    if (!signalForLoss) {
+        return false;
+    }
+    if (await not(bt.strategyCoreService.validatePartialLoss(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName }))) {
+        return false;
+    }
+    await Broker.commitPartialLoss({
+        symbol,
+        percentToClose,
+        cost: percentToCloseCost(percentToClose, investedCostForLoss),
+        currentPrice,
+        position: signalForLoss.position,
+        priceTakeProfit: signalForLoss.priceTakeProfit,
+        priceStopLoss: signalForLoss.priceStopLoss,
+        context: { exchangeName, frameName, strategyName },
+        backtest: isBacktest,
+    });
     return await bt.strategyCoreService.partialLoss(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
 }
 /**
@@ -30376,6 +31989,26 @@ async function commitTrailingStop(symbol, percentShift, currentPrice) {
     }
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    const signal = await bt.strategyCoreService.getPendingSignal(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+    if (!signal) {
+        return false;
+    }
+    const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    if (effectivePriceOpen === null) {
+        return false;
+    }
+    if (await not(bt.strategyCoreService.validateTrailingStop(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName }))) {
+        return false;
+    }
+    await Broker.commitTrailingStop({
+        symbol,
+        percentShift,
+        currentPrice,
+        newStopLossPrice: slPercentShiftToPrice(percentShift, signal.priceStopLoss, effectivePriceOpen, signal.position),
+        position: signal.position,
+        context: { exchangeName, frameName, strategyName },
+        backtest: isBacktest,
+    });
     return await bt.strategyCoreService.trailingStop(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
 }
 /**
@@ -30435,6 +32068,126 @@ async function commitTrailingTake(symbol, percentShift, currentPrice) {
     }
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    const signal = await bt.strategyCoreService.getPendingSignal(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+    if (!signal) {
+        return false;
+    }
+    const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    if (effectivePriceOpen === null) {
+        return false;
+    }
+    if (await not(bt.strategyCoreService.validateTrailingTake(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName }))) {
+        return false;
+    }
+    await Broker.commitTrailingTake({
+        symbol,
+        percentShift,
+        currentPrice,
+        newTakeProfitPrice: tpPercentShiftToPrice(percentShift, signal.priceTakeProfit, effectivePriceOpen, signal.position),
+        position: signal.position,
+        context: { exchangeName, frameName, strategyName },
+        backtest: isBacktest,
+    });
+    return await bt.strategyCoreService.trailingTake(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
+}
+/**
+ * Adjusts the trailing stop-loss to an absolute price level.
+ *
+ * Convenience wrapper around commitTrailingStop that converts an absolute
+ * stop-loss price to a percentShift relative to the ORIGINAL SL distance.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ * Automatically fetches current price via getAveragePrice.
+ *
+ * @param symbol - Trading pair symbol
+ * @param newStopLossPrice - Desired absolute stop-loss price
+ * @returns Promise<boolean> - true if trailing SL was set/updated, false if rejected
+ */
+async function commitTrailingStopCost(symbol, newStopLossPrice) {
+    bt.loggerService.info(TRAILING_STOP_COST_METHOD_NAME, {
+        symbol,
+        newStopLossPrice,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitTrailingStopCost requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitTrailingStopCost requires a method context");
+    }
+    const currentPrice = await getAveragePrice(symbol);
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    const signal = await bt.strategyCoreService.getPendingSignal(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+    if (!signal) {
+        return false;
+    }
+    const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    if (effectivePriceOpen === null) {
+        return false;
+    }
+    const percentShift = slPriceToPercentShift(newStopLossPrice, signal.priceStopLoss, effectivePriceOpen);
+    if (await not(bt.strategyCoreService.validateTrailingStop(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName }))) {
+        return false;
+    }
+    await Broker.commitTrailingStop({
+        symbol,
+        percentShift,
+        currentPrice,
+        newStopLossPrice,
+        position: signal.position,
+        context: { exchangeName, frameName, strategyName },
+        backtest: isBacktest,
+    });
+    return await bt.strategyCoreService.trailingStop(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
+}
+/**
+ * Adjusts the trailing take-profit to an absolute price level.
+ *
+ * Convenience wrapper around commitTrailingTake that converts an absolute
+ * take-profit price to a percentShift relative to the ORIGINAL TP distance.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ * Automatically fetches current price via getAveragePrice.
+ *
+ * @param symbol - Trading pair symbol
+ * @param newTakeProfitPrice - Desired absolute take-profit price
+ * @returns Promise<boolean> - true if trailing TP was set/updated, false if rejected
+ */
+async function commitTrailingTakeCost(symbol, newTakeProfitPrice) {
+    bt.loggerService.info(TRAILING_PROFIT_COST_METHOD_NAME, {
+        symbol,
+        newTakeProfitPrice,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitTrailingTakeCost requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitTrailingTakeCost requires a method context");
+    }
+    const currentPrice = await getAveragePrice(symbol);
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    const signal = await bt.strategyCoreService.getPendingSignal(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+    if (!signal) {
+        return false;
+    }
+    const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    if (effectivePriceOpen === null) {
+        return false;
+    }
+    const percentShift = tpPriceToPercentShift(newTakeProfitPrice, signal.priceTakeProfit, effectivePriceOpen);
+    if (await not(bt.strategyCoreService.validateTrailingTake(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName }))) {
+        return false;
+    }
+    await Broker.commitTrailingTake({
+        symbol,
+        percentShift,
+        currentPrice,
+        newTakeProfitPrice,
+        position: signal.position,
+        context: { exchangeName, frameName, strategyName },
+        backtest: isBacktest,
+    });
     return await bt.strategyCoreService.trailingTake(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
 }
 /**
@@ -30475,6 +32228,26 @@ async function commitBreakeven(symbol) {
     const currentPrice = await getAveragePrice(symbol);
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    const signal = await bt.strategyCoreService.getPendingSignal(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+    if (!signal) {
+        return false;
+    }
+    const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    if (effectivePriceOpen === null) {
+        return false;
+    }
+    if (await not(bt.strategyCoreService.validateBreakeven(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName }))) {
+        return false;
+    }
+    await Broker.commitBreakeven({
+        symbol,
+        currentPrice,
+        newStopLossPrice: breakevenNewStopLossPrice(effectivePriceOpen),
+        newTakeProfitPrice: breakevenNewTakeProfitPrice(signal.priceTakeProfit, signal._trailingPriceTakeProfit),
+        position: signal.position,
+        context: { exchangeName, frameName, strategyName },
+        backtest: isBacktest,
+    });
     return await bt.strategyCoreService.breakeven(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
 }
 /**
@@ -30549,6 +32322,23 @@ async function commitAverageBuy(symbol, cost = GLOBAL_CONFIG.CC_POSITION_ENTRY_C
     const currentPrice = await getAveragePrice(symbol);
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    if (await not(bt.strategyCoreService.validateAverageBuy(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName }))) {
+        return false;
+    }
+    const signalForAvgBuy = await bt.strategyCoreService.getPendingSignal(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+    if (!signalForAvgBuy) {
+        return false;
+    }
+    await Broker.commitAverageBuy({
+        symbol,
+        currentPrice,
+        cost,
+        position: signalForAvgBuy.position,
+        priceTakeProfit: signalForAvgBuy.priceTakeProfit,
+        priceStopLoss: signalForAvgBuy.priceStopLoss,
+        context: { exchangeName, frameName, strategyName },
+        backtest: isBacktest,
+    });
     return await bt.strategyCoreService.averageBuy(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName }, cost);
 }
 /**
@@ -30721,7 +32511,9 @@ async function getBreakeven(symbol, currentPrice) {
     return await bt.strategyCoreService.getBreakeven(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
 }
 async function getPositionAveragePrice(symbol) {
-    bt.loggerService.info(GET_POSITION_AVERAGE_PRICE_METHOD_NAME, { symbol });
+    bt.loggerService.info(GET_POSITION_AVERAGE_PRICE_METHOD_NAME, {
+        symbol,
+    });
     if (!ExecutionContextService.hasContext()) {
         throw new Error("getPositionAveragePrice requires an execution context");
     }
@@ -30733,7 +32525,9 @@ async function getPositionAveragePrice(symbol) {
     return await bt.strategyCoreService.getPositionAveragePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
 }
 async function getPositionInvestedCount(symbol) {
-    bt.loggerService.info(GET_POSITION_INVESTED_COUNT_METHOD_NAME, { symbol });
+    bt.loggerService.info(GET_POSITION_INVESTED_COUNT_METHOD_NAME, {
+        symbol,
+    });
     if (!ExecutionContextService.hasContext()) {
         throw new Error("getPositionInvestedCount requires an execution context");
     }
@@ -30745,7 +32539,9 @@ async function getPositionInvestedCount(symbol) {
     return await bt.strategyCoreService.getPositionInvestedCount(isBacktest, symbol, { exchangeName, frameName, strategyName });
 }
 async function getPositionInvestedCost(symbol) {
-    bt.loggerService.info(GET_POSITION_INVESTED_COST_METHOD_NAME, { symbol });
+    bt.loggerService.info(GET_POSITION_INVESTED_COST_METHOD_NAME, {
+        symbol,
+    });
     if (!ExecutionContextService.hasContext()) {
         throw new Error("getPositionInvestedCost requires an execution context");
     }
@@ -30799,7 +32595,10 @@ async function getPositionPnlPercent(symbol) {
  * ```
  */
 async function commitPartialProfitCost(symbol, dollarAmount) {
-    bt.loggerService.info(PARTIAL_PROFIT_COST_METHOD_NAME, { symbol, dollarAmount });
+    bt.loggerService.info(PARTIAL_PROFIT_COST_METHOD_NAME, {
+        symbol,
+        dollarAmount,
+    });
     if (!ExecutionContextService.hasContext()) {
         throw new Error("commitPartialProfitCost requires an execution context");
     }
@@ -30810,9 +32609,28 @@ async function commitPartialProfitCost(symbol, dollarAmount) {
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     const investedCost = await bt.strategyCoreService.getPositionInvestedCost(isBacktest, symbol, { exchangeName, frameName, strategyName });
-    if (investedCost === null)
+    if (investedCost === null) {
+        return false;
+    }
+    const signalForProfitCost = await bt.strategyCoreService.getPendingSignal(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+    if (!signalForProfitCost) {
         return false;
+    }
     const percentToClose = investedCostToPercent(dollarAmount, investedCost);
+    if (await not(bt.strategyCoreService.validatePartialProfit(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName }))) {
+        return false;
+    }
+    await Broker.commitPartialProfit({
+        symbol,
+        percentToClose,
+        cost: dollarAmount,
+        currentPrice,
+        position: signalForProfitCost.position,
+        priceTakeProfit: signalForProfitCost.priceTakeProfit,
+        priceStopLoss: signalForProfitCost.priceStopLoss,
+        context: { exchangeName, frameName, strategyName },
+        backtest: isBacktest,
+    });
     return await bt.strategyCoreService.partialProfit(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
 }
 /**
@@ -30845,7 +32663,10 @@ async function commitPartialProfitCost(symbol, dollarAmount) {
  * ```
  */
 async function commitPartialLossCost(symbol, dollarAmount) {
-    bt.loggerService.info(PARTIAL_LOSS_COST_METHOD_NAME, { symbol, dollarAmount });
+    bt.loggerService.info(PARTIAL_LOSS_COST_METHOD_NAME, {
+        symbol,
+        dollarAmount,
+    });
     if (!ExecutionContextService.hasContext()) {
         throw new Error("commitPartialLossCost requires an execution context");
     }
@@ -30856,9 +32677,28 @@ async function commitPartialLossCost(symbol, dollarAmount) {
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     const investedCost = await bt.strategyCoreService.getPositionInvestedCost(isBacktest, symbol, { exchangeName, frameName, strategyName });
-    if (investedCost === null)
+    if (investedCost === null) {
         return false;
+    }
+    const signalForLossCost = await bt.strategyCoreService.getPendingSignal(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
+    if (!signalForLossCost) {
+        return false;
+    }
     const percentToClose = investedCostToPercent(dollarAmount, investedCost);
+    if (await not(bt.strategyCoreService.validatePartialLoss(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName }))) {
+        return false;
+    }
+    await Broker.commitPartialLoss({
+        symbol,
+        percentToClose,
+        cost: dollarAmount,
+        currentPrice,
+        position: signalForLossCost.position,
+        priceTakeProfit: signalForLossCost.priceTakeProfit,
+        priceStopLoss: signalForLossCost.priceStopLoss,
+        context: { exchangeName, frameName, strategyName },
+        backtest: isBacktest,
+    });
     return await bt.strategyCoreService.partialLoss(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
 }
 async function getPositionPnlCost(symbol) {
@@ -30907,6 +32747,34 @@ async function getPositionLevels(symbol) {
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     return await bt.strategyCoreService.getPositionLevels(isBacktest, symbol, { exchangeName, frameName, strategyName });
 }
+/**
+ * Returns the list of partial close events for the current pending signal.
+ *
+ * Each element represents a partial profit or loss close executed via
+ * commitPartialProfit / commitPartialLoss (or their Cost variants).
+ *
+ * Returns null if no pending signal exists.
+ * Returns an empty array if no partials were executed yet.
+ *
+ * Each entry contains:
+ * - `type` — "profit" or "loss"
+ * - `percent` — percentage of position closed at this partial
+ * - `currentPrice` — execution price of the partial close
+ * - `costBasisAtClose` — accounting cost basis at the moment of this partial
+ * - `entryCountAtClose` — number of DCA entries accumulated at this partial
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to array of partial close records or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionPartials } from "backtest-kit";
+ *
+ * const partials = await getPositionPartials("BTCUSDT");
+ * // No partials yet: []
+ * // After one partial profit: [{ type: "profit", percent: 50, currentPrice: 45000, ... }]
+ * ```
+ */
 async function getPositionPartials(symbol) {
     bt.loggerService.info(GET_POSITION_PARTIALS_METHOD_NAME, { symbol });
     if (!ExecutionContextService.hasContext()) {
@@ -32153,6 +34021,8 @@ const BACKTEST_METHOD_NAME_PARTIAL_PROFIT_COST = "BacktestUtils.commitPartialPro
 const BACKTEST_METHOD_NAME_PARTIAL_LOSS_COST = "BacktestUtils.commitPartialLossCost";
 const BACKTEST_METHOD_NAME_TRAILING_STOP = "BacktestUtils.commitTrailingStop";
 const BACKTEST_METHOD_NAME_TRAILING_PROFIT = "BacktestUtils.commitTrailingTake";
+const BACKTEST_METHOD_NAME_TRAILING_STOP_COST = "BacktestUtils.commitTrailingStopCost";
+const BACKTEST_METHOD_NAME_TRAILING_PROFIT_COST = "BacktestUtils.commitTrailingTakeCost";
 const BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED = "Backtest.commitActivateScheduled";
 const BACKTEST_METHOD_NAME_AVERAGE_BUY = "Backtest.commitAverageBuy";
 const BACKTEST_METHOD_NAME_GET_DATA = "BacktestUtils.getData";
@@ -32332,12 +34202,13 @@ class BacktestInstance {
             }
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskGlobalService.clear({
-                    riskName,
-                    exchangeName: context.exchangeName,
-                    frameName: context.frameName,
-                    backtest: true,
-                });
+                riskName &&
+                    bt.riskGlobalService.clear({
+                        riskName,
+                        exchangeName: context.exchangeName,
+                        frameName: context.frameName,
+                        backtest: true,
+                    });
                 riskList &&
                     riskList.forEach((riskName) => bt.riskGlobalService.clear({
                         riskName,
@@ -32687,6 +34558,16 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getBreakeven(true, symbol, currentPrice, context);
         };
+        /**
+         * Returns the effective (weighted average) entry price for the current pending signal.
+         *
+         * Accounts for all DCA entries via commitAverageBuy.
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Effective entry price, or null if no active position
+         */
         this.getPositionAveragePrice = async (symbol, context) => {
             bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_AVERAGE_PRICE, {
                 symbol,
@@ -32705,6 +34586,15 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getPositionAveragePrice(true, symbol, context);
         };
+        /**
+         * Returns the total number of base-asset units currently held in the position.
+         *
+         * Includes units from all DCA entries. Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Total units held, or null if no active position
+         */
         this.getPositionInvestedCount = async (symbol, context) => {
             bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COUNT, {
                 symbol,
@@ -32723,6 +34613,15 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getPositionInvestedCount(true, symbol, context);
         };
+        /**
+         * Returns the total dollar cost invested in the current position.
+         *
+         * Sum of all entry costs across DCA entries. Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Total invested cost in quote currency, or null if no active position
+         */
         this.getPositionInvestedCost = async (symbol, context) => {
             bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COST, {
                 symbol,
@@ -32741,6 +34640,17 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getPositionInvestedCost(true, symbol, context);
         };
+        /**
+         * Returns the current unrealized PnL as a percentage of the invested cost.
+         *
+         * Calculated relative to the effective (weighted average) entry price.
+         * Positive for profit, negative for loss. Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns PnL percentage, or null if no active position
+         */
         this.getPositionPnlPercent = async (symbol, currentPrice, context) => {
             bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_PNL_PERCENT, {
                 symbol,
@@ -32760,6 +34670,17 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getPositionPnlPercent(true, symbol, currentPrice, context);
         };
+        /**
+         * Returns the current unrealized PnL in quote currency (dollar amount).
+         *
+         * Calculated as (currentPrice - effectiveEntry) * units for LONG,
+         * reversed for SHORT. Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns PnL in quote currency, or null if no active position
+         */
         this.getPositionPnlCost = async (symbol, currentPrice, context) => {
             bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_PNL_COST, {
                 symbol,
@@ -32779,6 +34700,18 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getPositionPnlCost(true, symbol, currentPrice, context);
         };
+        /**
+         * Returns the list of DCA entry prices for the current pending signal.
+         *
+         * The first element is always the original priceOpen (initial entry).
+         * Each subsequent element is a price added by commitAverageBuy().
+         * Returns null if no pending signal exists.
+         * Returns a single-element array [priceOpen] if no DCA entries were made.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Array of entry prices, or null if no active position
+         */
         this.getPositionLevels = async (symbol, context) => {
             bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_LEVELS, {
                 symbol,
@@ -32797,6 +34730,25 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getPositionLevels(true, symbol, context);
         };
+        /**
+         * Returns the list of partial close events for the current pending signal.
+         *
+         * Each element represents a partial profit or loss close executed via
+         * commitPartialProfit / commitPartialLoss (or their Cost variants).
+         * Returns null if no pending signal exists.
+         * Returns an empty array if no partials were executed yet.
+         *
+         * Each entry contains:
+         * - `type` — "profit" or "loss"
+         * - `percent` — percentage of position closed at this partial
+         * - `currentPrice` — execution price of the partial close
+         * - `costBasisAtClose` — accounting cost basis at the moment of this partial
+         * - `entryCountAtClose` — number of DCA entries accumulated at this partial
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Array of partial close records, or null if no active position
+         */
         this.getPositionPartials = async (symbol, context) => {
             bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_PARTIALS, {
                 symbol,
@@ -32985,6 +34937,28 @@ class BacktestUtils {
                 actions &&
                     actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT));
             }
+            const investedCostForProfit = await bt.strategyCoreService.getPositionInvestedCost(true, symbol, context);
+            if (investedCostForProfit === null) {
+                return false;
+            }
+            const signalForProfit = await bt.strategyCoreService.getPendingSignal(true, symbol, currentPrice, context);
+            if (!signalForProfit) {
+                return false;
+            }
+            if (await not(bt.strategyCoreService.validatePartialProfit(true, symbol, percentToClose, currentPrice, context))) {
+                return false;
+            }
+            await Broker.commitPartialProfit({
+                symbol,
+                percentToClose,
+                cost: percentToCloseCost(percentToClose, investedCostForProfit),
+                currentPrice,
+                position: signalForProfit.position,
+                priceTakeProfit: signalForProfit.priceTakeProfit,
+                priceStopLoss: signalForProfit.priceStopLoss,
+                context,
+                backtest: true,
+            });
             return await bt.strategyCoreService.partialProfit(true, symbol, percentToClose, currentPrice, context);
         };
         /**
@@ -33034,6 +35008,28 @@ class BacktestUtils {
                 actions &&
                     actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_PARTIAL_LOSS));
             }
+            const investedCostForLoss = await bt.strategyCoreService.getPositionInvestedCost(true, symbol, context);
+            if (investedCostForLoss === null) {
+                return false;
+            }
+            const signalForLoss = await bt.strategyCoreService.getPendingSignal(true, symbol, currentPrice, context);
+            if (!signalForLoss) {
+                return false;
+            }
+            if (await not(bt.strategyCoreService.validatePartialLoss(true, symbol, percentToClose, currentPrice, context))) {
+                return false;
+            }
+            await Broker.commitPartialLoss({
+                symbol,
+                percentToClose,
+                cost: percentToCloseCost(percentToClose, investedCostForLoss),
+                currentPrice,
+                position: signalForLoss.position,
+                priceTakeProfit: signalForLoss.priceTakeProfit,
+                priceStopLoss: signalForLoss.priceStopLoss,
+                context,
+                backtest: true,
+            });
             return await bt.strategyCoreService.partialLoss(true, symbol, percentToClose, currentPrice, context);
         };
         /**
@@ -33085,9 +35081,28 @@ class BacktestUtils {
                     actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT_COST));
             }
             const investedCost = await bt.strategyCoreService.getPositionInvestedCost(true, symbol, context);
-            if (investedCost === null)
+            if (investedCost === null) {
+                return false;
+            }
+            const signalForProfitCost = await bt.strategyCoreService.getPendingSignal(true, symbol, currentPrice, context);
+            if (!signalForProfitCost) {
                 return false;
+            }
             const percentToClose = (dollarAmount / investedCost) * 100;
+            if (await not(bt.strategyCoreService.validatePartialProfit(true, symbol, percentToClose, currentPrice, context))) {
+                return false;
+            }
+            await Broker.commitPartialProfit({
+                symbol,
+                percentToClose,
+                cost: dollarAmount,
+                currentPrice,
+                position: signalForProfitCost.position,
+                priceTakeProfit: signalForProfitCost.priceTakeProfit,
+                priceStopLoss: signalForProfitCost.priceStopLoss,
+                context,
+                backtest: true,
+            });
             return await bt.strategyCoreService.partialProfit(true, symbol, percentToClose, currentPrice, context);
         };
         /**
@@ -33139,9 +35154,28 @@ class BacktestUtils {
                     actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_PARTIAL_LOSS_COST));
             }
             const investedCost = await bt.strategyCoreService.getPositionInvestedCost(true, symbol, context);
-            if (investedCost === null)
+            if (investedCost === null) {
+                return false;
+            }
+            const signalForLossCost = await bt.strategyCoreService.getPendingSignal(true, symbol, currentPrice, context);
+            if (!signalForLossCost) {
                 return false;
+            }
             const percentToClose = (dollarAmount / investedCost) * 100;
+            if (await not(bt.strategyCoreService.validatePartialLoss(true, symbol, percentToClose, currentPrice, context))) {
+                return false;
+            }
+            await Broker.commitPartialLoss({
+                symbol,
+                percentToClose,
+                cost: dollarAmount,
+                currentPrice,
+                position: signalForLossCost.position,
+                priceTakeProfit: signalForLossCost.priceTakeProfit,
+                priceStopLoss: signalForLossCost.priceStopLoss,
+                context,
+                backtest: true,
+            });
             return await bt.strategyCoreService.partialLoss(true, symbol, percentToClose, currentPrice, context);
         };
         /**
@@ -33206,6 +35240,26 @@ class BacktestUtils {
                 actions &&
                     actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_TRAILING_STOP));
             }
+            const signal = await bt.strategyCoreService.getPendingSignal(true, symbol, currentPrice, context);
+            if (!signal) {
+                return false;
+            }
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(true, symbol, context);
+            if (effectivePriceOpen === null) {
+                return false;
+            }
+            if (await not(bt.strategyCoreService.validateTrailingStop(true, symbol, percentShift, currentPrice, context))) {
+                return false;
+            }
+            await Broker.commitTrailingStop({
+                symbol,
+                percentShift,
+                currentPrice,
+                newStopLossPrice: slPercentShiftToPrice(percentShift, signal.priceStopLoss, effectivePriceOpen, signal.position),
+                position: signal.position,
+                context,
+                backtest: true,
+            });
             return await bt.strategyCoreService.trailingStop(true, symbol, percentShift, currentPrice, context);
         };
         /**
@@ -33270,6 +35324,132 @@ class BacktestUtils {
                 actions &&
                     actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_TRAILING_PROFIT));
             }
+            const signal = await bt.strategyCoreService.getPendingSignal(true, symbol, currentPrice, context);
+            if (!signal) {
+                return false;
+            }
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(true, symbol, context);
+            if (effectivePriceOpen === null) {
+                return false;
+            }
+            if (await not(bt.strategyCoreService.validateTrailingTake(true, symbol, percentShift, currentPrice, context))) {
+                return false;
+            }
+            await Broker.commitTrailingTake({
+                symbol,
+                percentShift,
+                currentPrice,
+                newTakeProfitPrice: tpPercentShiftToPrice(percentShift, signal.priceTakeProfit, effectivePriceOpen, signal.position),
+                position: signal.position,
+                context,
+                backtest: true,
+            });
+            return await bt.strategyCoreService.trailingTake(true, symbol, percentShift, currentPrice, context);
+        };
+        /**
+         * Adjusts the trailing stop-loss to an absolute price level.
+         *
+         * Convenience wrapper around commitTrailingStop that converts an absolute
+         * stop-loss price to a percentShift relative to the ORIGINAL SL distance.
+         *
+         * @param symbol - Trading pair symbol
+         * @param newStopLossPrice - Desired absolute stop-loss price
+         * @param currentPrice - Current market price to check for intrusion
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Promise<boolean> - true if trailing SL was set/updated, false if rejected
+         */
+        this.commitTrailingStopCost = async (symbol, newStopLossPrice, currentPrice, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_TRAILING_STOP_COST, {
+                symbol,
+                newStopLossPrice,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_TRAILING_STOP_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_TRAILING_STOP_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_TRAILING_STOP_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_TRAILING_STOP_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_TRAILING_STOP_COST));
+            }
+            const signal = await bt.strategyCoreService.getPendingSignal(true, symbol, currentPrice, context);
+            if (!signal) {
+                return false;
+            }
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(true, symbol, context);
+            if (effectivePriceOpen === null) {
+                return false;
+            }
+            const percentShift = slPriceToPercentShift(newStopLossPrice, signal.priceStopLoss, effectivePriceOpen);
+            if (await not(bt.strategyCoreService.validateTrailingStop(true, symbol, percentShift, currentPrice, context))) {
+                return false;
+            }
+            await Broker.commitTrailingStop({
+                symbol,
+                percentShift,
+                currentPrice,
+                newStopLossPrice,
+                position: signal.position,
+                context,
+                backtest: true,
+            });
+            return await bt.strategyCoreService.trailingStop(true, symbol, percentShift, currentPrice, context);
+        };
+        /**
+         * Adjusts the trailing take-profit to an absolute price level.
+         *
+         * Convenience wrapper around commitTrailingTake that converts an absolute
+         * take-profit price to a percentShift relative to the ORIGINAL TP distance.
+         *
+         * @param symbol - Trading pair symbol
+         * @param newTakeProfitPrice - Desired absolute take-profit price
+         * @param currentPrice - Current market price to check for intrusion
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Promise<boolean> - true if trailing TP was set/updated, false if rejected
+         */
+        this.commitTrailingTakeCost = async (symbol, newTakeProfitPrice, currentPrice, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_TRAILING_PROFIT_COST, {
+                symbol,
+                newTakeProfitPrice,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_TRAILING_PROFIT_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_TRAILING_PROFIT_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_TRAILING_PROFIT_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_TRAILING_PROFIT_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_TRAILING_PROFIT_COST));
+            }
+            const signal = await bt.strategyCoreService.getPendingSignal(true, symbol, currentPrice, context);
+            if (!signal) {
+                return false;
+            }
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(true, symbol, context);
+            if (effectivePriceOpen === null) {
+                return false;
+            }
+            const percentShift = tpPriceToPercentShift(newTakeProfitPrice, signal.priceTakeProfit, effectivePriceOpen);
+            if (await not(bt.strategyCoreService.validateTrailingTake(true, symbol, percentShift, currentPrice, context))) {
+                return false;
+            }
+            await Broker.commitTrailingTake({
+                symbol,
+                percentShift,
+                currentPrice,
+                newTakeProfitPrice,
+                position: signal.position,
+                context,
+                backtest: true,
+            });
             return await bt.strategyCoreService.trailingTake(true, symbol, percentShift, currentPrice, context);
         };
         /**
@@ -33310,6 +35490,26 @@ class BacktestUtils {
                 actions &&
                     actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_BREAKEVEN));
             }
+            const signal = await bt.strategyCoreService.getPendingSignal(true, symbol, currentPrice, context);
+            if (!signal) {
+                return false;
+            }
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(true, symbol, context);
+            if (effectivePriceOpen === null) {
+                return false;
+            }
+            if (await not(bt.strategyCoreService.validateBreakeven(true, symbol, currentPrice, context))) {
+                return false;
+            }
+            await Broker.commitBreakeven({
+                symbol,
+                currentPrice,
+                newStopLossPrice: breakevenNewStopLossPrice(effectivePriceOpen),
+                newTakeProfitPrice: breakevenNewTakeProfitPrice(signal.priceTakeProfit, signal._trailingPriceTakeProfit),
+                position: signal.position,
+                context,
+                backtest: true,
+            });
             return await bt.strategyCoreService.breakeven(true, symbol, currentPrice, context);
         };
         /**
@@ -33393,6 +35593,23 @@ class BacktestUtils {
                 actions &&
                     actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_AVERAGE_BUY));
             }
+            if (await not(bt.strategyCoreService.validateAverageBuy(true, symbol, currentPrice, context))) {
+                return false;
+            }
+            const signalForAvgBuy = await bt.strategyCoreService.getPendingSignal(true, symbol, currentPrice, context);
+            if (!signalForAvgBuy) {
+                return false;
+            }
+            await Broker.commitAverageBuy({
+                symbol,
+                currentPrice,
+                cost,
+                position: signalForAvgBuy.position,
+                priceTakeProfit: signalForAvgBuy.priceTakeProfit,
+                priceStopLoss: signalForAvgBuy.priceStopLoss,
+                context,
+                backtest: true,
+            });
             return await bt.strategyCoreService.averageBuy(true, symbol, currentPrice, context, cost);
         };
         /**
@@ -33581,6 +35798,8 @@ const LIVE_METHOD_NAME_PARTIAL_PROFIT_COST = "LiveUtils.commitPartialProfitCost"
 const LIVE_METHOD_NAME_PARTIAL_LOSS_COST = "LiveUtils.commitPartialLossCost";
 const LIVE_METHOD_NAME_TRAILING_STOP = "LiveUtils.commitTrailingStop";
 const LIVE_METHOD_NAME_TRAILING_PROFIT = "LiveUtils.commitTrailingTake";
+const LIVE_METHOD_NAME_TRAILING_STOP_COST = "LiveUtils.commitTrailingStopCost";
+const LIVE_METHOD_NAME_TRAILING_PROFIT_COST = "LiveUtils.commitTrailingTakeCost";
 const LIVE_METHOD_NAME_ACTIVATE_SCHEDULED = "Live.commitActivateScheduled";
 const LIVE_METHOD_NAME_AVERAGE_BUY = "Live.commitAverageBuy";
 /**
@@ -33707,43 +35926,82 @@ class LiveInstance {
                 context,
             });
             {
-                bt.backtestMarkdownService.clear({ symbol, strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "", backtest: false });
-                bt.liveMarkdownService.clear({ symbol, strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "", backtest: false });
-                bt.scheduleMarkdownService.clear({ symbol, strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "", backtest: false });
-                bt.performanceMarkdownService.clear({ symbol, strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "", backtest: false });
-                bt.partialMarkdownService.clear({ symbol, strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "", backtest: false });
-                bt.riskMarkdownService.clear({ symbol, strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "", backtest: false });
-            }
-            {
-                bt.strategyCoreService.clear({
+                bt.backtestMarkdownService.clear({
                     symbol,
                     strategyName: context.strategyName,
                     exchangeName: context.exchangeName,
                     frameName: "",
                     backtest: false,
                 });
-            }
-            {
-                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskGlobalService.clear({
-                    riskName,
+                bt.liveMarkdownService.clear({
+                    symbol,
+                    strategyName: context.strategyName,
                     exchangeName: context.exchangeName,
                     frameName: "",
-                    backtest: false
+                    backtest: false,
                 });
-                riskList && riskList.forEach((riskName) => bt.riskGlobalService.clear({
-                    riskName,
+                bt.scheduleMarkdownService.clear({
+                    symbol,
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                    backtest: false,
+                });
+                bt.performanceMarkdownService.clear({
+                    symbol,
+                    strategyName: context.strategyName,
                     exchangeName: context.exchangeName,
                     frameName: "",
-                    backtest: false
-                }));
-                actions && actions.forEach((actionName) => bt.actionCoreService.clear({
-                    actionName,
+                    backtest: false,
+                });
+                bt.partialMarkdownService.clear({
+                    symbol,
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                    backtest: false,
+                });
+                bt.riskMarkdownService.clear({
+                    symbol,
                     strategyName: context.strategyName,
                     exchangeName: context.exchangeName,
                     frameName: "",
-                    backtest: false
-                }));
+                    backtest: false,
+                });
+            }
+            {
+                bt.strategyCoreService.clear({
+                    symbol,
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                    backtest: false,
+                });
+            }
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskGlobalService.clear({
+                        riskName,
+                        exchangeName: context.exchangeName,
+                        frameName: "",
+                        backtest: false,
+                    });
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskGlobalService.clear({
+                        riskName,
+                        exchangeName: context.exchangeName,
+                        frameName: "",
+                        backtest: false,
+                    }));
+                actions &&
+                    actions.forEach((actionName) => bt.actionCoreService.clear({
+                        actionName,
+                        strategyName: context.strategyName,
+                        exchangeName: context.exchangeName,
+                        frameName: "",
+                        backtest: false,
+                    }));
             }
             return bt.liveCommandService.run(symbol, context);
         };
@@ -33786,7 +36044,7 @@ class LiveInstance {
                 bt.strategyCoreService.stopStrategy(false, symbol, {
                     strategyName: context.strategyName,
                     exchangeName: context.exchangeName,
-                    frameName: ""
+                    frameName: "",
                 });
                 bt.strategyCoreService
                     .hasPendingSignal(false, symbol, {
@@ -33867,9 +36125,12 @@ class LiveUtils {
             }
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_RUN);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_RUN));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_RUN));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_RUN);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_RUN));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_RUN));
             }
             const instance = this._getInstance(symbol, context.strategyName, context.exchangeName);
             return instance.run(symbol, context);
@@ -33900,9 +36161,12 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_BACKGROUND);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BACKGROUND);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BACKGROUND));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_BACKGROUND));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BACKGROUND);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BACKGROUND));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_BACKGROUND));
             }
             const instance = this._getInstance(symbol, context.strategyName, context.exchangeName);
             return instance.background(symbol, context);
@@ -33932,9 +36196,12 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL));
             }
             return await bt.strategyCoreService.getPendingSignal(false, symbol, currentPrice, {
                 strategyName: context.strategyName,
@@ -33966,9 +36233,12 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED));
             }
             return await bt.strategyCoreService.getTotalPercentClosed(false, symbol, {
                 strategyName: context.strategyName,
@@ -33999,9 +36269,12 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED));
             }
             return await bt.strategyCoreService.getTotalCostClosed(false, symbol, {
                 strategyName: context.strategyName,
@@ -34034,9 +36307,12 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL));
             }
             return await bt.strategyCoreService.getScheduledSignal(false, symbol, currentPrice, {
                 strategyName: context.strategyName,
@@ -34077,9 +36353,12 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_BREAKEVEN);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_BREAKEVEN);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_BREAKEVEN));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_BREAKEVEN));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_BREAKEVEN);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_BREAKEVEN));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_BREAKEVEN));
             }
             return await bt.strategyCoreService.getBreakeven(false, symbol, currentPrice, {
                 strategyName: context.strategyName,
@@ -34087,15 +36366,31 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns the effective (weighted average) entry price for the current pending signal.
+         *
+         * Accounts for all DCA entries via commitAverageBuy.
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Effective entry price, or null if no active position
+         */
         this.getPositionAveragePrice = async (symbol, context) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE, { symbol, context });
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE, {
+                symbol,
+                context,
+            });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE);
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE));
             }
             return await bt.strategyCoreService.getPositionAveragePrice(false, symbol, {
                 strategyName: context.strategyName,
@@ -34103,15 +36398,30 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns the total number of base-asset units currently held in the position.
+         *
+         * Includes units from all DCA entries. Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Total units held, or null if no active position
+         */
         this.getPositionInvestedCount = async (symbol, context) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT, { symbol, context });
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT, {
+                symbol,
+                context,
+            });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT);
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT));
             }
             return await bt.strategyCoreService.getPositionInvestedCount(false, symbol, {
                 strategyName: context.strategyName,
@@ -34119,15 +36429,30 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns the total dollar cost invested in the current position.
+         *
+         * Sum of all entry costs across DCA entries. Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Total invested cost in quote currency, or null if no active position
+         */
         this.getPositionInvestedCost = async (symbol, context) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST, { symbol, context });
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST, {
+                symbol,
+                context,
+            });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST);
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST));
             }
             return await bt.strategyCoreService.getPositionInvestedCost(false, symbol, {
                 strategyName: context.strategyName,
@@ -34135,15 +36460,33 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns the current unrealized PnL as a percentage of the invested cost.
+         *
+         * Calculated relative to the effective (weighted average) entry price.
+         * Positive for profit, negative for loss. Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns PnL percentage, or null if no active position
+         */
         this.getPositionPnlPercent = async (symbol, currentPrice, context) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT, { symbol, currentPrice, context });
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT, {
+                symbol,
+                currentPrice,
+                context,
+            });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT);
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT));
             }
             return await bt.strategyCoreService.getPositionPnlPercent(false, symbol, currentPrice, {
                 strategyName: context.strategyName,
@@ -34151,15 +36494,33 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns the current unrealized PnL in quote currency (dollar amount).
+         *
+         * Calculated as (currentPrice - effectiveEntry) * units for LONG,
+         * reversed for SHORT. Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns PnL in quote currency, or null if no active position
+         */
         this.getPositionPnlCost = async (symbol, currentPrice, context) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_PNL_COST, { symbol, currentPrice, context });
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_PNL_COST, {
+                symbol,
+                currentPrice,
+                context,
+            });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_PNL_COST);
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_PNL_COST);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PNL_COST);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PNL_COST));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_PNL_COST));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_PNL_COST));
             }
             return await bt.strategyCoreService.getPositionPnlCost(false, symbol, currentPrice, {
                 strategyName: context.strategyName,
@@ -34167,15 +36528,33 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns the list of DCA entry prices for the current pending signal.
+         *
+         * The first element is always the original priceOpen (initial entry).
+         * Each subsequent element is a price added by commitAverageBuy().
+         * Returns null if no pending signal exists.
+         * Returns a single-element array [priceOpen] if no DCA entries were made.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Array of entry prices, or null if no active position
+         */
         this.getPositionLevels = async (symbol, context) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_LEVELS, { symbol, context });
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_LEVELS, {
+                symbol,
+                context,
+            });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_LEVELS);
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_LEVELS);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_LEVELS);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_LEVELS));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_LEVELS));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_LEVELS);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_LEVELS));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_LEVELS));
             }
             return await bt.strategyCoreService.getPositionLevels(false, symbol, {
                 strategyName: context.strategyName,
@@ -34183,15 +36562,40 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns the list of partial close events for the current pending signal.
+         *
+         * Each element represents a partial profit or loss close executed via
+         * commitPartialProfit / commitPartialLoss (or their Cost variants).
+         * Returns null if no pending signal exists.
+         * Returns an empty array if no partials were executed yet.
+         *
+         * Each entry contains:
+         * - `type` — "profit" or "loss"
+         * - `percent` — percentage of position closed at this partial
+         * - `currentPrice` — execution price of the partial close
+         * - `costBasisAtClose` — accounting cost basis at the moment of this partial
+         * - `entryCountAtClose` — number of DCA entries accumulated at this partial
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Array of partial close records, or null if no active position
+         */
         this.getPositionPartials = async (symbol, context) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_PARTIALS, { symbol, context });
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_PARTIALS, {
+                symbol,
+                context,
+            });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_PARTIALS);
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_PARTIALS);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PARTIALS);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PARTIALS));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_PARTIALS));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PARTIALS);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_PARTIALS));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_PARTIALS));
             }
             return await bt.strategyCoreService.getPositionPartials(false, symbol, {
                 strategyName: context.strategyName,
@@ -34225,9 +36629,12 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_STOP);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_STOP));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_STOP));
             }
             await bt.strategyCoreService.stopStrategy(false, symbol, {
                 strategyName: context.strategyName,
@@ -34268,9 +36675,12 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CANCEL_SCHEDULED);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL_SCHEDULED);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL_SCHEDULED));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_CANCEL_SCHEDULED));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL_SCHEDULED);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL_SCHEDULED));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_CANCEL_SCHEDULED));
             }
             await bt.strategyCoreService.cancelScheduled(false, symbol, {
                 strategyName: context.strategyName,
@@ -34309,9 +36719,12 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CLOSE_PENDING);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CLOSE_PENDING);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CLOSE_PENDING));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_CLOSE_PENDING));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CLOSE_PENDING);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CLOSE_PENDING));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_CLOSE_PENDING));
             }
             await bt.strategyCoreService.closePending(false, symbol, {
                 strategyName: context.strategyName,
@@ -34358,10 +36771,51 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_PARTIAL_PROFIT);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_PARTIAL_PROFIT));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_PARTIAL_PROFIT));
+            }
+            const investedCost = await bt.strategyCoreService.getPositionInvestedCost(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (investedCost === null) {
+                return false;
+            }
+            const signalForProfit = await bt.strategyCoreService.getPendingSignal(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (!signalForProfit) {
+                return false;
+            }
+            if (await not(bt.strategyCoreService.validatePartialProfit(false, symbol, percentToClose, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }))) {
+                return false;
             }
+            await Broker.commitPartialProfit({
+                symbol,
+                percentToClose,
+                cost: percentToCloseCost(percentToClose, investedCost),
+                currentPrice,
+                position: signalForProfit.position,
+                priceTakeProfit: signalForProfit.priceTakeProfit,
+                priceStopLoss: signalForProfit.priceStopLoss,
+                context: {
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                },
+                backtest: false,
+            });
             return await bt.strategyCoreService.partialProfit(false, symbol, percentToClose, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -34407,10 +36861,51 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_PARTIAL_LOSS);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_PARTIAL_LOSS));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_PARTIAL_LOSS));
+            }
+            const investedCost = await bt.strategyCoreService.getPositionInvestedCost(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (investedCost === null) {
+                return false;
+            }
+            const signalForLoss = await bt.strategyCoreService.getPendingSignal(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (!signalForLoss) {
+                return false;
             }
+            if (await not(bt.strategyCoreService.validatePartialLoss(false, symbol, percentToClose, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }))) {
+                return false;
+            }
+            await Broker.commitPartialLoss({
+                symbol,
+                percentToClose,
+                cost: percentToCloseCost(percentToClose, investedCost),
+                currentPrice,
+                position: signalForLoss.position,
+                priceTakeProfit: signalForLoss.priceTakeProfit,
+                priceStopLoss: signalForLoss.priceStopLoss,
+                context: {
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                },
+                backtest: false,
+            });
             return await bt.strategyCoreService.partialLoss(false, symbol, percentToClose, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -34447,23 +36942,62 @@ class LiveUtils {
          * ```
          */
         this.commitPartialProfitCost = async (symbol, dollarAmount, currentPrice, context) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_PARTIAL_PROFIT_COST, { symbol, dollarAmount, currentPrice, context });
+            bt.loggerService.info(LIVE_METHOD_NAME_PARTIAL_PROFIT_COST, {
+                symbol,
+                dollarAmount,
+                currentPrice,
+                context,
+            });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_PARTIAL_PROFIT_COST);
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_PARTIAL_PROFIT_COST);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT_COST);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT_COST));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_PARTIAL_PROFIT_COST));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_PARTIAL_PROFIT_COST));
             }
             const investedCost = await bt.strategyCoreService.getPositionInvestedCost(false, symbol, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
             });
-            if (investedCost === null)
+            if (investedCost === null) {
+                return false;
+            }
+            const signalForProfitCost = await bt.strategyCoreService.getPendingSignal(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (!signalForProfitCost) {
                 return false;
+            }
             const percentToClose = (dollarAmount / investedCost) * 100;
+            if (await not(bt.strategyCoreService.validatePartialProfit(false, symbol, percentToClose, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }))) {
+                return false;
+            }
+            await Broker.commitPartialProfit({
+                symbol,
+                percentToClose,
+                cost: dollarAmount,
+                currentPrice,
+                position: signalForProfitCost.position,
+                priceTakeProfit: signalForProfitCost.priceTakeProfit,
+                priceStopLoss: signalForProfitCost.priceStopLoss,
+                context: {
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                },
+                backtest: false,
+            });
             return await bt.strategyCoreService.partialProfit(false, symbol, percentToClose, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -34500,23 +37034,62 @@ class LiveUtils {
          * ```
          */
         this.commitPartialLossCost = async (symbol, dollarAmount, currentPrice, context) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_PARTIAL_LOSS_COST, { symbol, dollarAmount, currentPrice, context });
+            bt.loggerService.info(LIVE_METHOD_NAME_PARTIAL_LOSS_COST, {
+                symbol,
+                dollarAmount,
+                currentPrice,
+                context,
+            });
             bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_PARTIAL_LOSS_COST);
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_PARTIAL_LOSS_COST);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS_COST);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS_COST));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_PARTIAL_LOSS_COST));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_PARTIAL_LOSS_COST));
             }
             const investedCost = await bt.strategyCoreService.getPositionInvestedCost(false, symbol, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
             });
-            if (investedCost === null)
+            if (investedCost === null) {
+                return false;
+            }
+            const signalForLossCost = await bt.strategyCoreService.getPendingSignal(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (!signalForLossCost) {
                 return false;
+            }
             const percentToClose = (dollarAmount / investedCost) * 100;
+            if (await not(bt.strategyCoreService.validatePartialLoss(false, symbol, percentToClose, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }))) {
+                return false;
+            }
+            await Broker.commitPartialLoss({
+                symbol,
+                percentToClose,
+                cost: dollarAmount,
+                currentPrice,
+                position: signalForLossCost.position,
+                priceTakeProfit: signalForLossCost.priceTakeProfit,
+                priceStopLoss: signalForLossCost.priceStopLoss,
+                context: {
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                },
+                backtest: false,
+            });
             return await bt.strategyCoreService.partialLoss(false, symbol, percentToClose, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -34577,10 +37150,45 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_TRAILING_STOP);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_STOP);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_STOP));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_TRAILING_STOP));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_STOP);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_STOP));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_TRAILING_STOP));
             }
+            const signal = await bt.strategyCoreService.getPendingSignal(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (!signal) {
+                return false;
+            }
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (effectivePriceOpen === null) {
+                return false;
+            }
+            if (await not(bt.strategyCoreService.validateTrailingStop(false, symbol, percentShift, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }))) {
+                return false;
+            }
+            await Broker.commitTrailingStop({
+                symbol,
+                percentShift,
+                currentPrice,
+                newStopLossPrice: slPercentShiftToPrice(percentShift, signal.priceStopLoss, effectivePriceOpen, signal.position),
+                position: signal.position,
+                context,
+                backtest: false,
+            });
             return await bt.strategyCoreService.trailingStop(false, symbol, percentShift, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -34641,10 +37249,183 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_TRAILING_PROFIT);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_PROFIT);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_PROFIT));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_TRAILING_PROFIT));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_PROFIT);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_PROFIT));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_TRAILING_PROFIT));
+            }
+            const signal = await bt.strategyCoreService.getPendingSignal(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (!signal) {
+                return false;
+            }
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (effectivePriceOpen === null) {
+                return false;
             }
+            if (await not(bt.strategyCoreService.validateTrailingTake(false, symbol, percentShift, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }))) {
+                return false;
+            }
+            await Broker.commitTrailingTake({
+                symbol,
+                percentShift,
+                currentPrice,
+                newTakeProfitPrice: tpPercentShiftToPrice(percentShift, signal.priceTakeProfit, effectivePriceOpen, signal.position),
+                position: signal.position,
+                context,
+                backtest: false,
+            });
+            return await bt.strategyCoreService.trailingTake(false, symbol, percentShift, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Adjusts the trailing stop-loss to an absolute price level.
+         *
+         * Convenience wrapper around commitTrailingStop that converts an absolute
+         * stop-loss price to a percentShift relative to the ORIGINAL SL distance.
+         *
+         * @param symbol - Trading pair symbol
+         * @param newStopLossPrice - Desired absolute stop-loss price
+         * @param currentPrice - Current market price to check for intrusion
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise<boolean> - true if trailing SL was set/updated, false if rejected
+         */
+        this.commitTrailingStopCost = async (symbol, newStopLossPrice, currentPrice, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_TRAILING_STOP_COST, {
+                symbol,
+                newStopLossPrice,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_TRAILING_STOP_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_TRAILING_STOP_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_STOP_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_STOP_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_TRAILING_STOP_COST));
+            }
+            const signal = await bt.strategyCoreService.getPendingSignal(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (!signal) {
+                return false;
+            }
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (effectivePriceOpen === null) {
+                return false;
+            }
+            const percentShift = slPriceToPercentShift(newStopLossPrice, signal.priceStopLoss, effectivePriceOpen);
+            if (await not(bt.strategyCoreService.validateTrailingStop(false, symbol, percentShift, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }))) {
+                return false;
+            }
+            await Broker.commitTrailingStop({
+                symbol,
+                percentShift,
+                currentPrice,
+                newStopLossPrice,
+                position: signal.position,
+                context,
+                backtest: false,
+            });
+            return await bt.strategyCoreService.trailingStop(false, symbol, percentShift, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Adjusts the trailing take-profit to an absolute price level.
+         *
+         * Convenience wrapper around commitTrailingTake that converts an absolute
+         * take-profit price to a percentShift relative to the ORIGINAL TP distance.
+         *
+         * @param symbol - Trading pair symbol
+         * @param newTakeProfitPrice - Desired absolute take-profit price
+         * @param currentPrice - Current market price to check for intrusion
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise<boolean> - true if trailing TP was set/updated, false if rejected
+         */
+        this.commitTrailingTakeCost = async (symbol, newTakeProfitPrice, currentPrice, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_TRAILING_PROFIT_COST, {
+                symbol,
+                newTakeProfitPrice,
+                currentPrice,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_TRAILING_PROFIT_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_TRAILING_PROFIT_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_PROFIT_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_PROFIT_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_TRAILING_PROFIT_COST));
+            }
+            const signal = await bt.strategyCoreService.getPendingSignal(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (!signal) {
+                return false;
+            }
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (effectivePriceOpen === null) {
+                return false;
+            }
+            const percentShift = tpPriceToPercentShift(newTakeProfitPrice, signal.priceTakeProfit, effectivePriceOpen);
+            if (await not(bt.strategyCoreService.validateTrailingTake(false, symbol, percentShift, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }))) {
+                return false;
+            }
+            await Broker.commitTrailingTake({
+                symbol,
+                percentShift,
+                currentPrice,
+                newTakeProfitPrice,
+                position: signal.position,
+                context,
+                backtest: false,
+            });
             return await bt.strategyCoreService.trailingTake(false, symbol, percentShift, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -34682,10 +37463,49 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_BREAKEVEN);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BREAKEVEN);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BREAKEVEN));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_BREAKEVEN));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BREAKEVEN);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_BREAKEVEN));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_BREAKEVEN));
+            }
+            const signal = await bt.strategyCoreService.getPendingSignal(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (!signal) {
+                return false;
+            }
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (effectivePriceOpen === null) {
+                return false;
             }
+            if (await not(bt.strategyCoreService.validateBreakeven(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }))) {
+                return false;
+            }
+            await Broker.commitBreakeven({
+                symbol,
+                currentPrice,
+                newStopLossPrice: breakevenNewStopLossPrice(effectivePriceOpen),
+                newTakeProfitPrice: breakevenNewTakeProfitPrice(signal.priceTakeProfit, signal._trailingPriceTakeProfit),
+                position: signal.position,
+                context: {
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                },
+                backtest: false,
+            });
             return await bt.strategyCoreService.breakeven(false, symbol, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -34722,9 +37542,12 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED));
             }
             await bt.strategyCoreService.activateScheduled(false, symbol, {
                 strategyName: context.strategyName,
@@ -34765,10 +37588,42 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_AVERAGE_BUY);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_AVERAGE_BUY);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_AVERAGE_BUY));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_AVERAGE_BUY));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_AVERAGE_BUY);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_AVERAGE_BUY));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_AVERAGE_BUY));
+            }
+            if (await not(bt.strategyCoreService.validateAverageBuy(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }))) {
+                return false;
+            }
+            const signalForAvgBuy = await bt.strategyCoreService.getPendingSignal(false, symbol, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+            if (!signalForAvgBuy) {
+                return false;
             }
+            await Broker.commitAverageBuy({
+                symbol,
+                currentPrice,
+                cost,
+                position: signalForAvgBuy.position,
+                priceTakeProfit: signalForAvgBuy.priceTakeProfit,
+                priceStopLoss: signalForAvgBuy.priceStopLoss,
+                context: {
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                },
+                backtest: false,
+            });
             return await bt.strategyCoreService.averageBuy(false, symbol, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -34802,9 +37657,12 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_DATA));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_DATA));
             }
             return await bt.liveMarkdownService.getData(symbol, context.strategyName, context.exchangeName, "", false);
         };
@@ -34836,9 +37694,12 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_REPORT));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_REPORT));
             }
             return await bt.liveMarkdownService.getReport(symbol, context.strategyName, context.exchangeName, "", false, columns);
         };
@@ -34878,9 +37739,12 @@ class LiveUtils {
             bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_DUMP));
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_DUMP));
             }
             await bt.liveMarkdownService.dump(symbol, context.strategyName, context.exchangeName, "", false, path, columns);
         };
@@ -42468,4 +45332,4 @@ const percentValue = (yesterdayValue, todayValue) => {
     return yesterdayValue / todayValue - 1;
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Sync, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingTake, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionAveragePrice, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentValue, roundTicks, set, setColumns, setConfig, setLogger, shutdown, stopStrategy, toProfitLossDto, validate, waitForCandle, warmCandles };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Sync, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionAveragePrice, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, roundTicks, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, waitForCandle, warmCandles };