backtest-kit 3.8.1 → 4.0.1

package/build/index.cjs

@@ -7379,6 +7379,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).
      *
@@ -7514,6 +7560,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).
      *
@@ -7649,6 +7741,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.
      *
@@ -7771,6 +7939,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.
      *
@@ -7959,6 +8186,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.
      *
@@ -8133,6 +8419,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).
      *
@@ -8518,12 +8839,22 @@ const Risk = new RiskUtils();
  */
 const CREATE_SYNC_FN = (self, strategyName, exchangeName, frameName, backtest) => functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
     defaultValue: false,
 });
 /**
@@ -9224,6 +9555,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).
          *
@@ -9265,6 +9611,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).
          *
@@ -9306,6 +9667,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.
          *
@@ -9345,6 +9721,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.
          *
@@ -9384,6 +9775,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.
          *
@@ -9449,6 +9854,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.
          *
@@ -12807,6 +13226,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).
          *
@@ -12848,6 +13289,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).
          *
@@ -12917,6 +13380,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,
@@ -12952,6 +13437,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,
@@ -12983,6 +13490,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,
@@ -13038,6 +13565,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,
@@ -30157,6 +30704,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 = functoolsKit.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 = functoolsKit.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 = functoolsKit.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 = functoolsKit.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";
@@ -30165,6 +31732,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";
@@ -30294,6 +31863,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 functoolsKit.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 });
 }
 /**
@@ -30337,6 +31928,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 functoolsKit.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 });
 }
 /**
@@ -30396,6 +32009,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 functoolsKit.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 });
 }
 /**
@@ -30455,6 +32088,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 functoolsKit.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 functoolsKit.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 functoolsKit.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 });
 }
 /**
@@ -30495,6 +32248,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 functoolsKit.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 });
 }
 /**
@@ -30569,6 +32342,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 functoolsKit.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);
 }
 /**
@@ -30741,7 +32531,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");
     }
@@ -30753,7 +32545,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");
     }
@@ -30765,7 +32559,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");
     }
@@ -30819,7 +32615,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");
     }
@@ -30830,9 +32629,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 functoolsKit.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 });
 }
 /**
@@ -30865,7 +32683,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");
     }
@@ -30876,9 +32697,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 functoolsKit.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) {
@@ -30927,6 +32767,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()) {
@@ -32173,6 +34041,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";
@@ -32352,12 +34222,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,
@@ -32707,6 +34578,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,
@@ -32725,6 +34606,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,
@@ -32743,6 +34633,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,
@@ -32761,6 +34660,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,
@@ -32780,6 +34690,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,
@@ -32799,6 +34720,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,
@@ -32817,6 +34750,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,
@@ -33005,6 +34957,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 functoolsKit.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);
         };
         /**
@@ -33054,6 +35028,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 functoolsKit.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);
         };
         /**
@@ -33105,9 +35101,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 functoolsKit.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);
         };
         /**
@@ -33159,9 +35174,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 functoolsKit.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);
         };
         /**
@@ -33226,6 +35260,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 functoolsKit.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);
         };
         /**
@@ -33290,6 +35344,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 functoolsKit.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 functoolsKit.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 functoolsKit.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);
         };
         /**
@@ -33330,6 +35510,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 functoolsKit.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);
         };
         /**
@@ -33413,6 +35613,23 @@ class BacktestUtils {
                 actions &&
                     actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_AVERAGE_BUY));
             }
+            if (await functoolsKit.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);
         };
         /**
@@ -33601,6 +35818,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";
 /**
@@ -33727,43 +35946,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);
         };
@@ -33806,7 +36064,7 @@ class LiveInstance {
                 bt.strategyCoreService.stopStrategy(false, symbol, {
                     strategyName: context.strategyName,
                     exchangeName: context.exchangeName,
-                    frameName: ""
+                    frameName: "",
                 });
                 bt.strategyCoreService
                     .hasPendingSignal(false, symbol, {
@@ -33887,9 +36145,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);
@@ -33920,9 +36181,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);
@@ -33952,9 +36216,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,
@@ -33986,9 +36253,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,
@@ -34019,9 +36289,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,
@@ -34054,9 +36327,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,
@@ -34097,9 +36373,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,
@@ -34107,15 +36386,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,
@@ -34123,15 +36418,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,
@@ -34139,15 +36449,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,
@@ -34155,15 +36480,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,
@@ -34171,15 +36514,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,
@@ -34187,15 +36548,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,
@@ -34203,15 +36582,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,
@@ -34245,9 +36649,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,
@@ -34288,9 +36695,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,
@@ -34329,9 +36739,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,
@@ -34378,10 +36791,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 functoolsKit.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,
@@ -34427,10 +36881,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 functoolsKit.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,
@@ -34467,23 +36962,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 functoolsKit.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,
@@ -34520,23 +37054,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 functoolsKit.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,
@@ -34597,10 +37170,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 functoolsKit.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,
@@ -34661,10 +37269,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 functoolsKit.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 functoolsKit.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 functoolsKit.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,
@@ -34702,10 +37483,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 functoolsKit.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,
@@ -34742,9 +37562,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,
@@ -34785,10 +37608,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 functoolsKit.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,
@@ -34822,9 +37677,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);
         };
@@ -34856,9 +37714,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);
         };
@@ -34898,9 +37759,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);
         };
@@ -42491,6 +45355,8 @@ const percentValue = (yesterdayValue, todayValue) => {
 exports.ActionBase = ActionBase;
 exports.Backtest = Backtest;
 exports.Breakeven = Breakeven;
+exports.Broker = Broker;
+exports.BrokerBase = BrokerBase;
 exports.Cache = Cache;
 exports.Constant = Constant;
 exports.Exchange = Exchange;
@@ -42548,7 +45414,9 @@ exports.commitPartialLossCost = commitPartialLossCost;
 exports.commitPartialProfit = commitPartialProfit;
 exports.commitPartialProfitCost = commitPartialProfitCost;
 exports.commitTrailingStop = commitTrailingStop;
+exports.commitTrailingStopCost = commitTrailingStopCost;
 exports.commitTrailingTake = commitTrailingTake;
+exports.commitTrailingTakeCost = commitTrailingTakeCost;
 exports.dumpMessages = dumpMessages;
 exports.emitters = emitters;
 exports.formatPrice = formatPrice;
@@ -42646,6 +45514,7 @@ exports.overrideStrategySchema = overrideStrategySchema;
 exports.overrideWalkerSchema = overrideWalkerSchema;
 exports.parseArgs = parseArgs;
 exports.percentDiff = percentDiff;
+exports.percentToCloseCost = percentToCloseCost;
 exports.percentValue = percentValue;
 exports.roundTicks = roundTicks;
 exports.set = set;
@@ -42653,8 +45522,12 @@ exports.setColumns = setColumns;
 exports.setConfig = setConfig;
 exports.setLogger = setLogger;
 exports.shutdown = shutdown;
+exports.slPercentShiftToPrice = slPercentShiftToPrice;
+exports.slPriceToPercentShift = slPriceToPercentShift;
 exports.stopStrategy = stopStrategy;
 exports.toProfitLossDto = toProfitLossDto;
+exports.tpPercentShiftToPrice = tpPercentShiftToPrice;
+exports.tpPriceToPercentShift = tpPriceToPercentShift;
 exports.validate = validate;
 exports.waitForCandle = waitForCandle;
 exports.warmCandles = warmCandles;