backtest-kit 1.10.3 → 1.10.4

package/build/index.cjs

@@ -2676,193 +2676,167 @@ const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice) => {
         slClosed: slClosed + percentToClose,
     });
 };
-const TRAILING_STOP_FN = (self, signal, percentShift) => {
-    // Get current effective stop-loss (trailing or original)
-    const currentStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
-    // Calculate distance between entry and CURRENT stop-loss AS PERCENTAGE of entry price
-    const currentSlDistancePercent = Math.abs((signal.priceOpen - currentStopLoss) / signal.priceOpen * 100);
-    // Calculate new stop-loss distance percentage by adding shift to CURRENT distance
+const TRAILING_STOP_LOSS_FN = (self, signal, percentShift) => {
+    // CRITICAL: Always calculate from ORIGINAL SL, not from current trailing SL
+    // This prevents error accumulation on repeated calls
+    const originalSlDistancePercent = Math.abs((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen * 100);
+    // Calculate new stop-loss distance percentage by adding shift to ORIGINAL distance
     // Negative percentShift: reduces distance % (tightens stop, moves SL toward entry or beyond)
     // Positive percentShift: increases distance % (loosens stop, moves SL away from entry)
-    const newSlDistancePercent = currentSlDistancePercent + percentShift;
+    const newSlDistancePercent = originalSlDistancePercent + percentShift;
     // Calculate new stop-loss price based on new distance percentage
     // Negative newSlDistancePercent means SL crosses entry into profit zone
     let newStopLoss;
     if (signal.position === "long") {
         // LONG: SL is below entry (or above entry if in profit zone)
         // Formula: entry * (1 - newDistance%)
-        // Example: entry=100, currentSL=95 (5%), shift=-3% → newDistance=2% → 100 * 0.98 = 98 (tighter)
+        // Example: entry=100, originalSL=90 (10%), shift=-5% → newDistance=5% → 100 * 0.95 = 95 (tighter)
         newStopLoss = signal.priceOpen * (1 - newSlDistancePercent / 100);
     }
     else {
         // SHORT: SL is above entry (or below entry if in profit zone)
         // Formula: entry * (1 + newDistance%)
-        // Example: entry=100, currentSL=105 (5%), shift=-3% → newDistance=2% → 100 * 1.02 = 102 (tighter)
+        // Example: entry=100, originalSL=110 (10%), shift=-5% → newDistance=5% → 100 * 1.05 = 105 (tighter)
         newStopLoss = signal.priceOpen * (1 + newSlDistancePercent / 100);
     }
-    // Determine if this is the first trailing stop call (direction not set yet)
-    const isFirstCall = signal._trailingPriceStopLoss === undefined;
+    const currentTrailingSL = signal._trailingPriceStopLoss;
+    const isFirstCall = currentTrailingSL === undefined;
     if (isFirstCall) {
-        // First call: set the direction and update SL unconditionally
+        // First call: set trailing SL unconditionally
         signal._trailingPriceStopLoss = newStopLoss;
-        self.params.logger.info("TRAILING_STOP_FN executed (first call - direction set)", {
+        self.params.logger.info("TRAILING_STOP_FN executed (first call)", {
             signalId: signal.id,
             position: signal.position,
             priceOpen: signal.priceOpen,
             originalStopLoss: signal.priceStopLoss,
-            currentDistancePercent: currentSlDistancePercent,
-            previousStopLoss: currentStopLoss,
+            originalDistancePercent: originalSlDistancePercent,
             newStopLoss,
             newDistancePercent: newSlDistancePercent,
             percentShift,
             inProfitZone: signal.position === "long" ? newStopLoss > signal.priceOpen : newStopLoss < signal.priceOpen,
-            direction: newStopLoss > currentStopLoss ? "up" : "down",
         });
+        return true;
     }
     else {
-        // Subsequent calls: only update if new SL continues in the same direction
-        // Determine initial direction: "closer" or "farther" relative to entry
-        let initialDirection;
-        if (signal.position === "long") {
-            // LONG: closer = SL closer to entry = higher SL value (moving up)
-            initialDirection = signal._trailingPriceStopLoss > signal.priceStopLoss ? "closer" : "farther";
-        }
-        else {
-            // SHORT: closer = SL closer to entry = lower SL value (moving down)
-            initialDirection = signal._trailingPriceStopLoss < signal.priceStopLoss ? "closer" : "farther";
-        }
-        // Determine new direction
-        let newDirection;
+        // CRITICAL: Larger percentShift absorbs smaller one
+        // For LONG: higher SL (closer to entry) absorbs lower one
+        // For SHORT: lower SL (closer to entry) absorbs higher one
+        let shouldUpdate = false;
         if (signal.position === "long") {
-            // LONG: closer = higher SL value
-            newDirection = newStopLoss > currentStopLoss ? "closer" : "farther";
+            // LONG: update only if new SL is higher (better protection)
+            shouldUpdate = newStopLoss > currentTrailingSL;
         }
         else {
-            // SHORT: closer = lower SL value
-            newDirection = newStopLoss < currentStopLoss ? "closer" : "farther";
+            // SHORT: update only if new SL is lower (better protection)
+            shouldUpdate = newStopLoss < currentTrailingSL;
         }
-        // Only allow continuation in same direction
-        const shouldUpdate = initialDirection === newDirection;
         if (!shouldUpdate) {
-            self.params.logger.debug("TRAILING_STOP_FN: new SL not in same direction, skipping", {
+            self.params.logger.debug("TRAILING_STOP_FN: new SL not better than current, skipping", {
                 signalId: signal.id,
                 position: signal.position,
-                currentStopLoss,
+                currentTrailingSL,
                 newStopLoss,
                 percentShift,
-                initialDirection,
-                attemptedDirection: newDirection,
+                reason: "larger percentShift absorbs smaller one",
             });
-            return;
+            return false;
         }
         // Update trailing stop-loss
+        const previousTrailingSL = signal._trailingPriceStopLoss;
         signal._trailingPriceStopLoss = newStopLoss;
         self.params.logger.info("TRAILING_STOP_FN executed", {
             signalId: signal.id,
             position: signal.position,
             priceOpen: signal.priceOpen,
             originalStopLoss: signal.priceStopLoss,
-            currentDistancePercent: currentSlDistancePercent,
-            previousStopLoss: currentStopLoss,
+            originalDistancePercent: originalSlDistancePercent,
+            previousTrailingSL,
             newStopLoss,
             newDistancePercent: newSlDistancePercent,
             percentShift,
             inProfitZone: signal.position === "long" ? newStopLoss > signal.priceOpen : newStopLoss < signal.priceOpen,
-            direction: initialDirection,
         });
+        return true;
     }
 };
-const TRAILING_PROFIT_FN = (self, signal, percentShift) => {
-    // Get current effective take-profit (trailing or original)
-    const currentTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
-    // Calculate distance between entry and CURRENT take-profit AS PERCENTAGE of entry price
-    const currentTpDistancePercent = Math.abs((currentTakeProfit - signal.priceOpen) / signal.priceOpen * 100);
-    // Calculate new take-profit distance percentage by adding shift to CURRENT distance
+const TRAILING_TAKE_PROFIT_FN = (self, signal, percentShift) => {
+    // CRITICAL: Always calculate from ORIGINAL TP, not from current trailing TP
+    // This prevents error accumulation on repeated calls
+    const originalTpDistancePercent = Math.abs((signal.priceTakeProfit - signal.priceOpen) / signal.priceOpen * 100);
+    // Calculate new take-profit distance percentage by adding shift to ORIGINAL distance
     // Negative percentShift: reduces distance % (brings TP closer to entry)
     // Positive percentShift: increases distance % (moves TP further from entry)
-    const newTpDistancePercent = currentTpDistancePercent + percentShift;
+    const newTpDistancePercent = originalTpDistancePercent + percentShift;
     // Calculate new take-profit price based on new distance percentage
     let newTakeProfit;
     if (signal.position === "long") {
         // LONG: TP is above entry
         // Formula: entry * (1 + newDistance%)
-        // Example: entry=100, currentTP=115 (15%), shift=-3% → newDistance=12% → 100 * 1.12 = 112 (closer)
+        // Example: entry=100, originalTP=110 (10%), shift=-3% → newDistance=7% → 100 * 1.07 = 107 (closer)
         newTakeProfit = signal.priceOpen * (1 + newTpDistancePercent / 100);
     }
     else {
         // SHORT: TP is below entry
         // Formula: entry * (1 - newDistance%)
-        // Example: entry=100, currentTP=85 (15%), shift=-3% → newDistance=12% → 100 * 0.88 = 88 (closer)
+        // Example: entry=100, originalTP=90 (10%), shift=-3% → newDistance=7% → 100 * 0.93 = 93 (closer)
         newTakeProfit = signal.priceOpen * (1 - newTpDistancePercent / 100);
     }
-    // Determine if this is the first trailing profit call (direction not set yet)
-    const isFirstCall = signal._trailingPriceTakeProfit === undefined;
+    const currentTrailingTP = signal._trailingPriceTakeProfit;
+    const isFirstCall = currentTrailingTP === undefined;
     if (isFirstCall) {
-        // First call: set the direction and update TP unconditionally
+        // First call: set trailing TP unconditionally
         signal._trailingPriceTakeProfit = newTakeProfit;
-        self.params.logger.info("TRAILING_PROFIT_FN executed (first call - direction set)", {
+        self.params.logger.info("TRAILING_PROFIT_FN executed (first call)", {
             signalId: signal.id,
             position: signal.position,
             priceOpen: signal.priceOpen,
             originalTakeProfit: signal.priceTakeProfit,
-            currentDistancePercent: currentTpDistancePercent,
-            previousTakeProfit: currentTakeProfit,
+            originalDistancePercent: originalTpDistancePercent,
             newTakeProfit,
             newDistancePercent: newTpDistancePercent,
             percentShift,
-            direction: newTakeProfit > currentTakeProfit ? "up" : "down",
         });
+        return true;
     }
     else {
-        // Subsequent calls: only update if new TP continues in the same direction
-        // Determine initial direction: "closer" or "farther" relative to entry
-        let initialDirection;
-        if (signal.position === "long") {
-            // LONG: closer = TP closer to entry = lower TP value
-            initialDirection = signal._trailingPriceTakeProfit < signal.priceTakeProfit ? "closer" : "farther";
-        }
-        else {
-            // SHORT: closer = TP closer to entry = higher TP value  
-            initialDirection = signal._trailingPriceTakeProfit > signal.priceTakeProfit ? "closer" : "farther";
-        }
-        // Determine new direction
-        let newDirection;
+        // CRITICAL: Larger percentShift absorbs smaller one
+        // For LONG: lower TP (closer to entry) absorbs higher one
+        // For SHORT: higher TP (closer to entry) absorbs lower one
+        let shouldUpdate = false;
         if (signal.position === "long") {
-            // LONG: closer = lower TP value
-            newDirection = newTakeProfit < currentTakeProfit ? "closer" : "farther";
+            // LONG: update only if new TP is lower (closer to entry, more conservative)
+            shouldUpdate = newTakeProfit < currentTrailingTP;
         }
         else {
-            // SHORT: closer = higher TP value
-            newDirection = newTakeProfit > currentTakeProfit ? "closer" : "farther";
+            // SHORT: update only if new TP is higher (closer to entry, more conservative)
+            shouldUpdate = newTakeProfit > currentTrailingTP;
         }
-        // Only allow continuation in same direction
-        const shouldUpdate = initialDirection === newDirection;
         if (!shouldUpdate) {
-            self.params.logger.debug("TRAILING_PROFIT_FN: new TP not in same direction, skipping", {
+            self.params.logger.debug("TRAILING_PROFIT_FN: new TP not better than current, skipping", {
                 signalId: signal.id,
                 position: signal.position,
-                currentTakeProfit,
+                currentTrailingTP,
                 newTakeProfit,
                 percentShift,
-                initialDirection,
-                attemptedDirection: newDirection,
+                reason: "larger percentShift absorbs smaller one",
             });
-            return;
+            return false;
         }
         // Update trailing take-profit
+        const previousTrailingTP = signal._trailingPriceTakeProfit;
         signal._trailingPriceTakeProfit = newTakeProfit;
         self.params.logger.info("TRAILING_PROFIT_FN executed", {
             signalId: signal.id,
             position: signal.position,
             priceOpen: signal.priceOpen,
             originalTakeProfit: signal.priceTakeProfit,
-            currentDistancePercent: currentTpDistancePercent,
-            previousTakeProfit: currentTakeProfit,
+            originalDistancePercent: originalTpDistancePercent,
+            previousTrailingTP,
             newTakeProfit,
             newDistancePercent: newTpDistancePercent,
             percentShift,
-            direction: initialDirection,
         });
+        return true;
     }
 };
 const BREAKEVEN_FN = (self, signal, currentPrice) => {
@@ -3212,7 +3186,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
         _isScheduled: false,
     };
     await self.setPendingSignal(activatedSignal);
-    await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, activationTime, self.params.execution.context.backtest);
+    await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, activatedSignal, activationTime, self.params.execution.context.backtest);
     await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, self._pendingSignal, self._pendingSignal.priceOpen, activationTime, self.params.execution.context.backtest);
     const result = {
         action: "opened",
@@ -3412,13 +3386,20 @@ const CALL_IDLE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, curren
         errorEmitter.next(error);
     },
 });
-const CALL_RISK_ADD_SIGNAL_FN = functoolsKit.trycatch(async (self, symbol, timestamp, backtest) => {
+const CALL_RISK_ADD_SIGNAL_FN = functoolsKit.trycatch(async (self, symbol, signal, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
         await self.params.risk.addSignal(symbol, {
             strategyName: self.params.method.context.strategyName,
             riskName: self.params.riskName,
             exchangeName: self.params.method.context.exchangeName,
             frameName: self.params.method.context.frameName,
+        }, {
+            position: signal.position,
+            priceOpen: signal.priceOpen,
+            priceStopLoss: signal.priceStopLoss,
+            priceTakeProfit: signal.priceTakeProfit,
+            minuteEstimatedTime: signal.minuteEstimatedTime,
+            openTimestamp: timestamp,
         });
     }, {
         when: new Date(timestamp),
@@ -3652,7 +3633,7 @@ const OPEN_NEW_PENDING_SIGNAL_FN = async (self, signal) => {
     if (await functoolsKit.not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, signal, signal.priceOpen, currentTime, self.params.execution.context.backtest))) {
         return null;
     }
-    await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, currentTime, self.params.execution.context.backtest);
+    await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, signal, currentTime, self.params.execution.context.backtest);
     await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, signal.priceOpen, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "opened",
@@ -3880,7 +3861,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
         _isScheduled: false,
     };
     await self.setPendingSignal(activatedSignal);
-    await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, activationTime, self.params.execution.context.backtest);
+    await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, activatedSignal, activationTime, self.params.execution.context.backtest);
     await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, activatedSignal, activatedSignal.priceOpen, activationTime, self.params.execution.context.backtest);
     return true;
 };
@@ -4783,6 +4764,28 @@ class ClientStrategy {
                 throw new Error(`ClientStrategy partialProfit: For SHORT position, currentPrice (${currentPrice}) must be < priceOpen (${this._pendingSignal.priceOpen})`);
             }
         }
+        // Check if currentPrice already crossed take profit level
+        const effectiveTakeProfit = this._pendingSignal._trailingPriceTakeProfit ?? this._pendingSignal.priceTakeProfit;
+        if (this._pendingSignal.position === "long" && currentPrice >= effectiveTakeProfit) {
+            this.params.logger.debug("ClientStrategy partialProfit: price already at/above TP, skipping partial close", {
+                signalId: this._pendingSignal.id,
+                position: this._pendingSignal.position,
+                currentPrice,
+                effectiveTakeProfit,
+                reason: "currentPrice >= effectiveTakeProfit (LONG position)"
+            });
+            return;
+        }
+        if (this._pendingSignal.position === "short" && currentPrice <= effectiveTakeProfit) {
+            this.params.logger.debug("ClientStrategy partialProfit: price already at/below TP, skipping partial close", {
+                signalId: this._pendingSignal.id,
+                position: this._pendingSignal.position,
+                currentPrice,
+                effectiveTakeProfit,
+                reason: "currentPrice <= effectiveTakeProfit (SHORT position)"
+            });
+            return;
+        }
         // Execute partial close logic
         PARTIAL_PROFIT_FN(this, this._pendingSignal, percentToClose, currentPrice);
         // Persist updated signal state (inline setPendingSignal content)
@@ -4875,6 +4878,28 @@ class ClientStrategy {
                 throw new Error(`ClientStrategy partialLoss: For SHORT position, currentPrice (${currentPrice}) must be > priceOpen (${this._pendingSignal.priceOpen})`);
             }
         }
+        // Check if currentPrice already crossed stop loss level
+        const effectiveStopLoss = this._pendingSignal._trailingPriceStopLoss ?? this._pendingSignal.priceStopLoss;
+        if (this._pendingSignal.position === "long" && currentPrice <= effectiveStopLoss) {
+            this.params.logger.debug("ClientStrategy partialLoss: price already at/below SL, skipping partial close", {
+                signalId: this._pendingSignal.id,
+                position: this._pendingSignal.position,
+                currentPrice,
+                effectiveStopLoss,
+                reason: "currentPrice <= effectiveStopLoss (LONG position)"
+            });
+            return;
+        }
+        if (this._pendingSignal.position === "short" && currentPrice >= effectiveStopLoss) {
+            this.params.logger.debug("ClientStrategy partialLoss: price already at/above SL, skipping partial close", {
+                signalId: this._pendingSignal.id,
+                position: this._pendingSignal.position,
+                currentPrice,
+                effectiveStopLoss,
+                reason: "currentPrice >= effectiveStopLoss (SHORT position)"
+            });
+            return;
+        }
         // Execute partial close logic
         PARTIAL_LOSS_FN(this, this._pendingSignal, percentToClose, currentPrice);
         // Persist updated signal state (inline setPendingSignal content)
@@ -4956,6 +4981,34 @@ class ClientStrategy {
         if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0) {
             throw new Error(`ClientStrategy breakeven: currentPrice must be a positive finite number, got ${currentPrice}`);
         }
+        // Check for conflict with existing trailing take profit
+        const signal = this._pendingSignal;
+        const breakevenPrice = signal.priceOpen;
+        const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
+        if (signal.position === "long" && breakevenPrice >= effectiveTakeProfit) {
+            // LONG: Breakeven SL would be at or above current TP - invalid configuration
+            this.params.logger.debug("ClientStrategy breakeven: SL/TP conflict detected, skipping breakeven", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                breakevenPrice,
+                effectiveTakeProfit,
+                reason: "breakevenPrice >= effectiveTakeProfit (LONG position)"
+            });
+            return false;
+        }
+        if (signal.position === "short" && breakevenPrice <= effectiveTakeProfit) {
+            // SHORT: Breakeven SL would be at or below current TP - invalid configuration
+            this.params.logger.debug("ClientStrategy breakeven: SL/TP conflict detected, skipping breakeven", {
+                signalId: signal.id,
+                position: signal.position,
+                priceOpen: signal.priceOpen,
+                breakevenPrice,
+                effectiveTakeProfit,
+                reason: "breakevenPrice <= effectiveTakeProfit (SHORT position)"
+            });
+            return false;
+        }
         // Execute breakeven logic
         const result = BREAKEVEN_FN(this, this._pendingSignal, currentPrice);
         // Only persist if breakeven was actually set
@@ -4980,24 +5033,35 @@ class ClientStrategy {
     /**
      * Adjusts trailing stop-loss by shifting distance between entry and original SL.
      *
-     * Calculates new SL based on percentage shift of the distance (entry - originalSL):
+     * CRITICAL: Always calculates from ORIGINAL SL, not from current trailing SL.
+     * This prevents error accumulation on repeated calls.
+     * Larger percentShift ABSORBS smaller one (updates only towards better protection).
+     *
+     * Calculates new SL based on percentage shift of the ORIGINAL distance (entry - originalSL):
      * - Negative %: tightens stop (moves SL closer to entry, reduces risk)
      * - Positive %: loosens stop (moves SL away from entry, allows more drawdown)
      *
-     * For LONG position (entry=100, originalSL=90, distance=10):
-     * - percentShift = -50: newSL = 100 - 10*(1-0.5) = 95 (tighter, closer to entry)
-     * - percentShift = +20: newSL = 100 - 10*(1+0.2) = 88 (looser, away from entry)
+     * For LONG position (entry=100, originalSL=90, distance=10%):
+     * - percentShift = -50: newSL = 100 - 10%*(1-0.5) = 95 (5% distance, tighter)
+     * - percentShift = +20: newSL = 100 - 10%*(1+0.2) = 88 (12% distance, looser)
+     *
+     * For SHORT position (entry=100, originalSL=110, distance=10%):
+     * - percentShift = -50: newSL = 100 + 10%*(1-0.5) = 105 (5% distance, tighter)
+     * - percentShift = +20: newSL = 100 + 10%*(1+0.2) = 112 (12% distance, looser)
      *
-     * For SHORT position (entry=100, originalSL=110, distance=10):
-     * - percentShift = -50: newSL = 100 + 10*(1-0.5) = 105 (tighter, closer to entry)
-     * - percentShift = +20: newSL = 100 + 10*(1+0.2) = 112 (looser, away from entry)
+     * Trailing behavior (absorption):
+     * - First call: sets trailing SL unconditionally
+     * - Subsequent calls: updates only if new SL is BETTER (protects more profit)
+     * - For LONG: only accepts HIGHER SL (never moves down, closer to entry wins)
+     * - For SHORT: only accepts LOWER SL (never moves up, closer to entry wins)
+     * - Stores in _trailingPriceStopLoss, original priceStopLoss always preserved
      *
-     * Trailing behavior:
-     * - Only updates if new SL is BETTER (protects more profit)
-     * - For LONG: only accepts higher SL (never moves down)
-     * - For SHORT: only accepts lower SL (never moves up)
-     * - Validates that SL never crosses entry price
-     * - Stores in _trailingPriceStopLoss, original priceStopLoss preserved
+     * Example of absorption (LONG, entry=100, originalSL=90):
+     * ```typescript
+     * await trailingStop(-50, price); // Sets SL=95 (first call)
+     * await trailingStop(-30, price); // SKIPPED: SL=97 < 95 (worse, not absorbed)
+     * await trailingStop(-70, price); // Sets SL=97 (better, absorbs previous)
+     * ```
      *
      * Validation:
      * - Throws if no pending signal exists
@@ -5007,28 +5071,34 @@ class ClientStrategy {
      * - Throws if currentPrice is not a positive finite number
      * - Skips if new SL would cross entry price
      * - Skips if currentPrice already crossed new SL level (price intrusion protection)
+     * - Skips if new SL conflicts with existing trailing take-profit
      *
      * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-     * @param percentShift - Percentage shift of SL distance [-100, 100], excluding 0
+     * @param percentShift - Percentage shift of ORIGINAL SL distance [-100, 100], excluding 0
      * @param currentPrice - Current market price to check for intrusion
      * @param backtest - Whether running in backtest mode (controls persistence)
-     * @returns Promise that resolves when trailing SL is updated and persisted
+     * @returns Promise<boolean> - true if trailing SL was set/updated, false if rejected (absorption/intrusion/conflict)
      *
      * @example
      * ```typescript
      * // LONG position: entry=100, originalSL=90, distance=10%, currentPrice=102
      *
      * // Move SL 50% closer to entry (tighten): reduces distance by 50%
-     * await strategy.trailingStop("BTCUSDT", -50, 102, false);
-     * // newDistance = 10% - 50% = 5%, newSL = 100 * (1 - 0.05) = 95
+     * const success1 = await strategy.trailingStop("BTCUSDT", -50, 102, false);
+     * // success1 = true, newDistance = 10% - 50% = 5%, newSL = 100 * (1 - 0.05) = 95
      *
-     * // Move SL 30% away from entry (loosen): increases distance by 30%
-     * await strategy.trailingStop("BTCUSDT", 30, 102, false);
-     * // newDistance = 10% + 30% = 40%, newSL = 100 * (1 - 0.4) = 60
+     * // Try to move SL only 30% closer (less aggressive)
+     * const success2 = await strategy.trailingStop("BTCUSDT", -30, 102, false);
+     * // success2 = false (SKIPPED: newSL=97 < 95, worse protection, larger % absorbs smaller)
+     *
+     * // Move SL 70% closer to entry (more aggressive)
+     * const success3 = await strategy.trailingStop("BTCUSDT", -70, 102, false);
+     * // success3 = true, newDistance = 10% - 70% = 3%, newSL = 100 * (1 - 0.03) = 97
+     * // Updated! SL=97 > 95 (better protection)
      *
      * // Price intrusion example: currentPrice=92, trying to set SL=95
-     * await strategy.trailingStop("BTCUSDT", -50, 92, false);
-     * // SKIPPED: currentPrice (92) < newSL (95) - would trigger immediate stop
+     * const success4 = await strategy.trailingStop("BTCUSDT", -50, 92, false);
+     * // success4 = false (SKIPPED: currentPrice (92) < newSL (95) - would trigger immediate stop)
      * ```
      */
     async trailingStop(symbol, percentShift, currentPrice, backtest) {
@@ -5078,7 +5148,7 @@ class ClientStrategy {
                 currentPrice,
                 reason: "currentPrice below newStopLoss (LONG position)"
             });
-            return;
+            return false;
         }
         if (signal.position === "short" && currentPrice > newStopLoss) {
             // SHORT: Price already crossed the new stop loss level - skip setting SL
@@ -5090,7 +5160,7 @@ class ClientStrategy {
                 currentPrice,
                 reason: "currentPrice above newStopLoss (SHORT position)"
             });
-            return;
+            return false;
         }
         // Check for conflict with existing trailing take profit
         const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
@@ -5104,7 +5174,7 @@ class ClientStrategy {
                 effectiveTakeProfit,
                 reason: "newStopLoss >= effectiveTakeProfit (LONG position)"
             });
-            return;
+            return false;
         }
         if (signal.position === "short" && newStopLoss <= effectiveTakeProfit) {
             // SHORT: New SL would be at or below current TP - invalid configuration
@@ -5116,10 +5186,14 @@ class ClientStrategy {
                 effectiveTakeProfit,
                 reason: "newStopLoss <= effectiveTakeProfit (SHORT position)"
             });
-            return;
+            return false;
+        }
+        // Execute trailing logic and get result
+        const wasUpdated = TRAILING_STOP_LOSS_FN(this, this._pendingSignal, percentShift);
+        // If trailing was not updated (absorption rejected), return false without persistence
+        if (!wasUpdated) {
+            return false;
         }
-        // Execute trailing logic
-        TRAILING_STOP_FN(this, this._pendingSignal, percentShift);
         // Persist updated signal state (inline setPendingSignal content)
         // Note: this._pendingSignal already mutated by TRAILING_STOP_FN, no reassignment needed
         this.params.logger.debug("ClientStrategy setPendingSignal (inline)", {
@@ -5133,36 +5207,67 @@ class ClientStrategy {
         if (!backtest) {
             await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
         }
+        return true;
     }
     /**
      * Adjusts the trailing take-profit distance for an active pending signal.
      *
-     * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
-     * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
-     * Once direction is set on first call, subsequent calls must continue in same direction.
+     * CRITICAL: Always calculates from ORIGINAL TP, not from current trailing TP.
+     * This prevents error accumulation on repeated calls.
+     * Larger percentShift ABSORBS smaller one (updates only towards more conservative TP).
+     *
+     * Updates the take-profit distance by a percentage adjustment relative to the ORIGINAL TP distance.
+     * Negative percentShift brings TP closer to entry (more conservative).
+     * Positive percentShift moves TP further from entry (more aggressive).
+     *
+     * Trailing behavior (absorption):
+     * - First call: sets trailing TP unconditionally
+     * - Subsequent calls: updates only if new TP is MORE CONSERVATIVE (closer to entry)
+     * - For LONG: only accepts LOWER TP (never moves up, closer to entry wins)
+     * - For SHORT: only accepts HIGHER TP (never moves down, closer to entry wins)
+     * - Stores in _trailingPriceTakeProfit, original priceTakeProfit always preserved
+     *
+     * Example of absorption (LONG, entry=100, originalTP=110):
+     * ```typescript
+     * await trailingTake(-30, price); // Sets TP=107 (first call, 7% distance)
+     * await trailingTake(+20, price); // SKIPPED: TP=112 > 107 (less conservative)
+     * await trailingTake(-50, price); // Sets TP=105 (more conservative, absorbs previous)
+     * ```
      *
      * Price intrusion protection: If current price has already crossed the new TP level,
      * the update is skipped to prevent immediate TP triggering.
      *
      * @param symbol - Trading pair symbol
-     * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+     * @param percentShift - Percentage adjustment to ORIGINAL TP distance (-100 to 100)
      * @param currentPrice - Current market price to check for intrusion
      * @param backtest - Whether running in backtest mode
-     * @returns Promise that resolves when trailing TP is updated
+     * @returns Promise<boolean> - true if trailing TP was set/updated, false if rejected (absorption/intrusion/conflict)
      *
      * @example
      * ```typescript
      * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
-     * // Move TP further by 50%: newTP = 100 + 15% = 115
-     * await strategy.trailingProfit("BTCUSDT", 50, 102, false);
+     *
+     * // Move TP closer by 30% (more conservative)
+     * const success1 = await strategy.trailingTake("BTCUSDT", -30, 102, false);
+     * // success1 = true, newDistance = 10% - 30% = 7%, newTP = 100 * (1 + 0.07) = 107
+     *
+     * // Try to move TP further by 20% (less conservative)
+     * const success2 = await strategy.trailingTake("BTCUSDT", 20, 102, false);
+     * // success2 = false (SKIPPED: newTP=112 > 107, less conservative, larger % absorbs smaller)
+     *
+     * // Move TP even closer by 50% (most conservative)
+     * const success3 = await strategy.trailingTake("BTCUSDT", -50, 102, false);
+     * // success3 = true, newDistance = 10% - 50% = 5%, newTP = 100 * (1 + 0.05) = 105
+     * // Updated! TP=105 < 107 (more conservative)
      *
      * // SHORT: entry=100, originalTP=90, distance=10%, currentPrice=98
      * // Move TP closer by 30%: newTP = 100 - 7% = 93
-     * await strategy.trailingProfit("BTCUSDT", -30, 98, false);
+     * const success4 = await strategy.trailingTake("BTCUSDT", -30, 98, false);
+     * // success4 = true
      * ```
      */
-    async trailingProfit(symbol, percentShift, currentPrice, backtest) {
-        this.params.logger.debug("ClientStrategy trailingProfit", {
+    async trailingTake(symbol, percentShift, currentPrice, backtest) {
+        this.params.logger.debug("ClientStrategy trailingTake", {
             symbol,
             percentShift,
             currentPrice,
@@ -5170,21 +5275,21 @@ class ClientStrategy {
         });
         // Validation: must have pending signal
         if (!this._pendingSignal) {
-            throw new Error(`ClientStrategy trailingProfit: No pending signal exists for symbol=${symbol}`);
+            throw new Error(`ClientStrategy trailingTake: No pending signal exists for symbol=${symbol}`);
         }
         // Validation: percentShift must be valid
         if (typeof percentShift !== "number" || !isFinite(percentShift)) {
-            throw new Error(`ClientStrategy trailingProfit: percentShift must be a finite number, got ${percentShift} (${typeof percentShift})`);
+            throw new Error(`ClientStrategy trailingTake: percentShift must be a finite number, got ${percentShift} (${typeof percentShift})`);
         }
         if (percentShift < -100 || percentShift > 100) {
-            throw new Error(`ClientStrategy trailingProfit: percentShift must be in range [-100, 100], got ${percentShift}`);
+            throw new Error(`ClientStrategy trailingTake: percentShift must be in range [-100, 100], got ${percentShift}`);
         }
         if (percentShift === 0) {
-            throw new Error(`ClientStrategy trailingProfit: percentShift cannot be 0`);
+            throw new Error(`ClientStrategy trailingTake: percentShift cannot be 0`);
         }
         // Validation: currentPrice must be valid
         if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0) {
-            throw new Error(`ClientStrategy trailingProfit: currentPrice must be a positive finite number, got ${currentPrice}`);
+            throw new Error(`ClientStrategy trailingTake: currentPrice must be a positive finite number, got ${currentPrice}`);
         }
         // Calculate what the new take profit would be
         const signal = this._pendingSignal;
@@ -5200,7 +5305,7 @@ class ClientStrategy {
         // Check for price intrusion before executing trailing logic
         if (signal.position === "long" && currentPrice > newTakeProfit) {
             // LONG: Price already crossed the new take profit level - skip setting TP
-            this.params.logger.debug("ClientStrategy trailingProfit: price intrusion detected, skipping TP update", {
+            this.params.logger.debug("ClientStrategy trailingTake: price intrusion detected, skipping TP update", {
                 signalId: signal.id,
                 position: signal.position,
                 priceOpen: signal.priceOpen,
@@ -5208,11 +5313,11 @@ class ClientStrategy {
                 currentPrice,
                 reason: "currentPrice above newTakeProfit (LONG position)"
             });
-            return;
+            return false;
         }
         if (signal.position === "short" && currentPrice < newTakeProfit) {
             // SHORT: Price already crossed the new take profit level - skip setting TP
-            this.params.logger.debug("ClientStrategy trailingProfit: price intrusion detected, skipping TP update", {
+            this.params.logger.debug("ClientStrategy trailingTake: price intrusion detected, skipping TP update", {
                 signalId: signal.id,
                 position: signal.position,
                 priceOpen: signal.priceOpen,
@@ -5220,13 +5325,13 @@ class ClientStrategy {
                 currentPrice,
                 reason: "currentPrice below newTakeProfit (SHORT position)"
             });
-            return;
+            return false;
         }
         // Check for conflict with existing trailing stop loss
         const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
         if (signal.position === "long" && newTakeProfit <= effectiveStopLoss) {
             // LONG: New TP would be at or below current SL - invalid configuration
-            this.params.logger.debug("ClientStrategy trailingProfit: TP/SL conflict detected, skipping TP update", {
+            this.params.logger.debug("ClientStrategy trailingTake: TP/SL conflict detected, skipping TP update", {
                 signalId: signal.id,
                 position: signal.position,
                 priceOpen: signal.priceOpen,
@@ -5234,11 +5339,11 @@ class ClientStrategy {
                 effectiveStopLoss,
                 reason: "newTakeProfit <= effectiveStopLoss (LONG position)"
             });
-            return;
+            return false;
         }
         if (signal.position === "short" && newTakeProfit >= effectiveStopLoss) {
             // SHORT: New TP would be at or above current SL - invalid configuration
-            this.params.logger.debug("ClientStrategy trailingProfit: TP/SL conflict detected, skipping TP update", {
+            this.params.logger.debug("ClientStrategy trailingTake: TP/SL conflict detected, skipping TP update", {
                 signalId: signal.id,
                 position: signal.position,
                 priceOpen: signal.priceOpen,
@@ -5246,10 +5351,14 @@ class ClientStrategy {
                 effectiveStopLoss,
                 reason: "newTakeProfit >= effectiveStopLoss (SHORT position)"
             });
-            return;
+            return false;
+        }
+        // Execute trailing logic and get result
+        const wasUpdated = TRAILING_TAKE_PROFIT_FN(this, this._pendingSignal, percentShift);
+        // If trailing was not updated (absorption rejected), return false without persistence
+        if (!wasUpdated) {
+            return false;
         }
-        // Execute trailing logic
-        TRAILING_PROFIT_FN(this, this._pendingSignal, percentShift);
         // Persist updated signal state (inline setPendingSignal content)
         // Note: this._pendingSignal already mutated by TRAILING_PROFIT_FN, no reassignment needed
         this.params.logger.debug("ClientStrategy setPendingSignal (inline)", {
@@ -5263,6 +5372,7 @@ class ClientStrategy {
         if (!backtest) {
             await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
         }
+        return true;
     }
 }
 
@@ -5341,12 +5451,12 @@ class MergeRisk {
      * @param context - Context with strategyName, riskName, exchangeName and frameName
      * @returns Promise that resolves when all risks have registered the signal
      */
-    async addSignal(symbol, context) {
+    async addSignal(symbol, context, positionData) {
         bt.loggerService.info("MergeRisk addSignal", {
             symbol,
             context,
         });
-        await Promise.all(this._riskList.map(async (risk) => await risk.addSignal(symbol, context)));
+        await Promise.all(this._riskList.map(async (risk) => await risk.addSignal(symbol, context, positionData)));
     }
     /**
      * Removes a signal from all child risk profiles.
@@ -5434,6 +5544,7 @@ class RiskUtils {
             });
             bt.strategyValidationService.validate(context.strategyName, RISK_METHOD_NAME_GET_DATA);
             bt.exchangeValidationService.validate(context.exchangeName, RISK_METHOD_NAME_GET_DATA);
+            context.frameName && bt.frameValidationService.validate(context.frameName, RISK_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -5491,6 +5602,7 @@ class RiskUtils {
             });
             bt.strategyValidationService.validate(context.strategyName, RISK_METHOD_NAME_GET_REPORT);
             bt.exchangeValidationService.validate(context.exchangeName, RISK_METHOD_NAME_GET_REPORT);
+            context.frameName && bt.frameValidationService.validate(context.frameName, RISK_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -5540,6 +5652,7 @@ class RiskUtils {
             });
             bt.strategyValidationService.validate(context.strategyName, RISK_METHOD_NAME_DUMP);
             bt.exchangeValidationService.validate(context.exchangeName, RISK_METHOD_NAME_DUMP);
+            context.frameName && bt.frameValidationService.validate(context.frameName, RISK_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
@@ -6050,7 +6163,7 @@ class StrategyConnectionService {
                 backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.trailingStop(symbol, percentShift, currentPrice, backtest);
+            return await strategy.trailingStop(symbol, percentShift, currentPrice, backtest);
         };
         /**
          * Adjusts the trailing take-profit distance for an active pending signal.
@@ -6058,7 +6171,7 @@ class StrategyConnectionService {
          * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
          * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
          *
-         * Delegates to ClientStrategy.trailingProfit() with current execution context.
+         * Delegates to ClientStrategy.trailingTake() with current execution context.
          *
          * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
@@ -6071,7 +6184,7 @@ class StrategyConnectionService {
          * ```typescript
          * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
          * // Move TP further by 50%: newTP = 100 + 15% = 115
-         * await strategyConnectionService.trailingProfit(
+         * await strategyConnectionService.trailingTake(
          *   false,
          *   "BTCUSDT",
          *   50,
@@ -6080,8 +6193,8 @@ class StrategyConnectionService {
          * );
          * ```
          */
-        this.trailingProfit = async (backtest, symbol, percentShift, currentPrice, context) => {
-            this.loggerService.log("strategyConnectionService trailingProfit", {
+        this.trailingTake = async (backtest, symbol, percentShift, currentPrice, context) => {
+            this.loggerService.log("strategyConnectionService trailingTake", {
                 symbol,
                 context,
                 percentShift,
@@ -6089,7 +6202,7 @@ class StrategyConnectionService {
                 backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.trailingProfit(symbol, percentShift, currentPrice, backtest);
+            return await strategy.trailingTake(symbol, percentShift, currentPrice, backtest);
         };
         /**
          * Delegates to ClientStrategy.breakeven() with current execution context.
@@ -6783,10 +6896,11 @@ class ClientRisk {
      * Registers a new opened signal.
      * Called by StrategyConnectionService after signal is opened.
      */
-    async addSignal(symbol, context) {
+    async addSignal(symbol, context, positionData) {
         this.params.logger.debug("ClientRisk addSignal", {
             symbol,
             context,
+            positionData,
             backtest: this.params.backtest,
         });
         if (this._activePositions === POSITION_NEED_FETCH) {
@@ -6797,7 +6911,14 @@ class ClientRisk {
         riskMap.set(key, {
             strategyName: context.strategyName,
             exchangeName: context.exchangeName,
-            openTimestamp: Date.now(),
+            frameName: context.frameName,
+            symbol,
+            position: positionData.position,
+            priceOpen: positionData.priceOpen,
+            priceStopLoss: positionData.priceStopLoss,
+            priceTakeProfit: positionData.priceTakeProfit,
+            minuteEstimatedTime: positionData.minuteEstimatedTime,
+            openTimestamp: positionData.openTimestamp,
         });
         await this._updatePositions();
     }
@@ -6947,13 +7068,15 @@ class RiskConnectionService {
          *
          * @param symbol - Trading pair symbol
          * @param payload - Payload information (strategyName, riskName, exchangeName, frameName, backtest)
+         * @param positionData - Position data (position, prices, timing)
          */
-        this.addSignal = async (symbol, payload) => {
+        this.addSignal = async (symbol, payload, positionData) => {
             this.loggerService.log("riskConnectionService addSignal", {
                 symbol,
                 payload,
+                positionData,
             });
-            await this.getRisk(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest).addSignal(symbol, payload);
+            await this.getRisk(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest).addSignal(symbol, payload, positionData);
         };
         /**
          * Removes a closed signal from the risk management system.
@@ -7178,6 +7301,8 @@ class StrategyCoreService {
         this.strategySchemaService = inject(TYPES.strategySchemaService);
         this.riskValidationService = inject(TYPES.riskValidationService);
         this.strategyValidationService = inject(TYPES.strategyValidationService);
+        this.exchangeValidationService = inject(TYPES.exchangeValidationService);
+        this.frameValidationService = inject(TYPES.frameValidationService);
         /**
          * Validates strategy and associated risk configuration.
          *
@@ -7187,13 +7312,14 @@ class StrategyCoreService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = functoolsKit.memoize(([symbol, context]) => `${symbol}:${context.strategyName}:${context.exchangeName}:${context.frameName}`, async (symbol, context) => {
+        this.validate = functoolsKit.memoize(([context]) => `${context.strategyName}:${context.exchangeName}:${context.frameName}`, async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE, {
-                symbol,
                 context,
             });
             const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
             this.strategyValidationService.validate(context.strategyName, METHOD_NAME_VALIDATE);
+            this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_VALIDATE);
+            context.frameName && this.frameValidationService.validate(context.frameName, METHOD_NAME_VALIDATE);
             riskName && this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE);
             riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE));
         });
@@ -7212,7 +7338,7 @@ class StrategyCoreService {
                 symbol,
                 context,
             });
-            await this.validate(symbol, context);
+            await this.validate(context);
             return await this.strategyConnectionService.getPendingSignal(backtest, symbol, context);
         };
         /**
@@ -7230,7 +7356,7 @@ class StrategyCoreService {
                 symbol,
                 context,
             });
-            await this.validate(symbol, context);
+            await this.validate(context);
             return await this.strategyConnectionService.getScheduledSignal(backtest, symbol, context);
         };
         /**
@@ -7270,7 +7396,7 @@ class StrategyCoreService {
                 context,
                 backtest,
             });
-            await this.validate(symbol, context);
+            await this.validate(context);
             return await this.strategyConnectionService.getBreakeven(backtest, symbol, currentPrice, context);
         };
         /**
@@ -7290,7 +7416,7 @@ class StrategyCoreService {
                 context,
                 backtest,
             });
-            await this.validate(symbol, context);
+            await this.validate(context);
             return await this.strategyConnectionService.getStopped(backtest, symbol, context);
         };
         /**
@@ -7312,7 +7438,7 @@ class StrategyCoreService {
                 backtest,
                 context,
             });
-            await this.validate(symbol, context);
+            await this.validate(context);
             return await ExecutionContextService.runInContext(async () => {
                 return await this.strategyConnectionService.tick(symbol, context);
             }, {
@@ -7342,7 +7468,7 @@ class StrategyCoreService {
                 backtest,
                 context,
             });
-            await this.validate(symbol, context);
+            await this.validate(context);
             return await ExecutionContextService.runInContext(async () => {
                 return await this.strategyConnectionService.backtest(symbol, context, candles);
             }, {
@@ -7368,7 +7494,7 @@ class StrategyCoreService {
                 context,
                 backtest,
             });
-            await this.validate(symbol, context);
+            await this.validate(context);
             return await this.strategyConnectionService.stop(backtest, symbol, context);
         };
         /**
@@ -7391,7 +7517,7 @@ class StrategyCoreService {
                 backtest,
                 cancelId,
             });
-            await this.validate(symbol, context);
+            await this.validate(context);
             return await this.strategyConnectionService.cancel(backtest, symbol, context, cancelId);
         };
         /**
@@ -7407,7 +7533,7 @@ class StrategyCoreService {
                 payload,
             });
             if (payload) {
-                await this.validate(payload.symbol, {
+                await this.validate({
                     strategyName: payload.strategyName,
                     exchangeName: payload.exchangeName,
                     frameName: payload.frameName
@@ -7450,7 +7576,7 @@ class StrategyCoreService {
                 context,
                 backtest,
             });
-            await this.validate(symbol, context);
+            await this.validate(context);
             return await this.strategyConnectionService.partialProfit(backtest, symbol, percentToClose, currentPrice, context);
         };
         /**
@@ -7488,7 +7614,7 @@ class StrategyCoreService {
                 context,
                 backtest,
             });
-            await this.validate(symbol, context);
+            await this.validate(context);
             return await this.strategyConnectionService.partialLoss(backtest, symbol, percentToClose, currentPrice, context);
         };
         /**
@@ -7527,7 +7653,7 @@ class StrategyCoreService {
                 context,
                 backtest,
             });
-            await this.validate(symbol, context);
+            await this.validate(context);
             return await this.strategyConnectionService.trailingStop(backtest, symbol, percentShift, currentPrice, context);
         };
         /**
@@ -7545,7 +7671,7 @@ class StrategyCoreService {
          * ```typescript
          * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
          * // Move TP further by 50%: newTP = 100 + 15% = 115
-         * await strategyCoreService.trailingProfit(
+         * await strategyCoreService.trailingTake(
          *   false,
          *   "BTCUSDT",
          *   50,
@@ -7554,16 +7680,16 @@ class StrategyCoreService {
          * );
          * ```
          */
-        this.trailingProfit = async (backtest, symbol, percentShift, currentPrice, context) => {
-            this.loggerService.log("strategyCoreService trailingProfit", {
+        this.trailingTake = async (backtest, symbol, percentShift, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService trailingTake", {
                 symbol,
                 percentShift,
                 currentPrice,
                 context,
                 backtest,
             });
-            await this.validate(symbol, context);
-            return await this.strategyConnectionService.trailingProfit(backtest, symbol, percentShift, currentPrice, context);
+            await this.validate(context);
+            return await this.strategyConnectionService.trailingTake(backtest, symbol, percentShift, currentPrice, context);
         };
         /**
          * Moves stop-loss to breakeven when price reaches threshold.
@@ -7592,7 +7718,7 @@ class StrategyCoreService {
                 context,
                 backtest,
             });
-            await this.validate(symbol, context);
+            await this.validate(context);
             return await this.strategyConnectionService.breakeven(backtest, symbol, currentPrice, context);
         };
     }
@@ -7673,6 +7799,7 @@ class RiskGlobalService {
         this.riskConnectionService = inject(TYPES.riskConnectionService);
         this.riskValidationService = inject(TYPES.riskValidationService);
         this.exchangeValidationService = inject(TYPES.exchangeValidationService);
+        this.frameValidationService = inject(TYPES.frameValidationService);
         /**
          * Validates risk configuration.
          * Memoized to avoid redundant validations for the same risk-exchange-frame combination.
@@ -7686,6 +7813,7 @@ class RiskGlobalService {
             });
             this.riskValidationService.validate(payload.riskName, "riskGlobalService validate");
             this.exchangeValidationService.validate(payload.exchangeName, "riskGlobalService validate");
+            payload.frameName && this.frameValidationService.validate(payload.frameName, "riskGlobalService validate");
         });
         /**
          * Checks if a signal should be allowed based on risk limits.
@@ -7707,14 +7835,16 @@ class RiskGlobalService {
          *
          * @param symbol - Trading pair symbol
          * @param payload - Payload information (strategyName, riskName, exchangeName, frameName, backtest)
+         * @param positionData - Position data (position, prices, timing)
          */
-        this.addSignal = async (symbol, payload) => {
+        this.addSignal = async (symbol, payload, positionData) => {
             this.loggerService.log("riskGlobalService addSignal", {
                 symbol,
                 payload,
+                positionData,
             });
             await this.validate(payload);
-            await this.riskConnectionService.addSignal(symbol, payload);
+            await this.riskConnectionService.addSignal(symbol, payload, positionData);
         };
         /**
          * Removes a closed signal from the risk management system.
@@ -15962,6 +16092,10 @@ class PartialGlobalService {
          * Exchange validation service for validating exchange existence.
          */
         this.exchangeValidationService = inject(TYPES.exchangeValidationService);
+        /**
+         * Frame validation service for validating frame existence.
+         */
+        this.frameValidationService = inject(TYPES.frameValidationService);
         /**
          * Validates strategy and associated risk configuration.
          * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
@@ -15976,6 +16110,7 @@ class PartialGlobalService {
             });
             this.strategyValidationService.validate(context.strategyName, methodName);
             this.exchangeValidationService.validate(context.exchangeName, methodName);
+            context.frameName && this.frameValidationService.validate(context.frameName, methodName);
             const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
             riskName && this.riskValidationService.validate(riskName, methodName);
             riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
@@ -16941,6 +17076,10 @@ class BreakevenGlobalService {
          * Exchange validation service for validating exchange existence.
          */
         this.exchangeValidationService = inject(TYPES.exchangeValidationService);
+        /**
+         * Frame validation service for validating frame existence.
+         */
+        this.frameValidationService = inject(TYPES.frameValidationService);
         /**
          * Validates strategy and associated risk configuration.
          * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
@@ -16955,6 +17094,7 @@ class BreakevenGlobalService {
             });
             this.strategyValidationService.validate(context.strategyName, methodName);
             this.exchangeValidationService.validate(context.exchangeName, methodName);
+            context.frameName && this.frameValidationService.validate(context.frameName, methodName);
             const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
             riskName && this.riskValidationService.validate(riskName, methodName);
             riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
@@ -18268,7 +18408,7 @@ const CANCEL_METHOD_NAME = "strategy.cancel";
 const PARTIAL_PROFIT_METHOD_NAME = "strategy.partialProfit";
 const PARTIAL_LOSS_METHOD_NAME = "strategy.partialLoss";
 const TRAILING_STOP_METHOD_NAME = "strategy.trailingStop";
-const TRAILING_PROFIT_METHOD_NAME = "strategy.trailingProfit";
+const TRAILING_PROFIT_METHOD_NAME = "strategy.trailingTake";
 const BREAKEVEN_METHOD_NAME = "strategy.breakeven";
 /**
  * Stops the strategy from generating new signals.
@@ -18429,23 +18569,44 @@ async function partialLoss(symbol, percentToClose) {
 /**
  * Adjusts the trailing stop-loss distance for an active pending signal.
  *
- * Updates the stop-loss distance by a percentage adjustment relative to the original SL distance.
- * Positive percentShift tightens the SL (reduces distance), negative percentShift loosens it.
+ * CRITICAL: Always calculates from ORIGINAL SL, not from current trailing SL.
+ * This prevents error accumulation on repeated calls.
+ * Larger percentShift ABSORBS smaller one (updates only towards better protection).
+ *
+ * Updates the stop-loss distance by a percentage adjustment relative to the ORIGINAL SL distance.
+ * Negative percentShift tightens the SL (reduces distance, moves closer to entry).
+ * Positive percentShift loosens the SL (increases distance, moves away from entry).
+ *
+ * Absorption behavior:
+ * - First call: sets trailing SL unconditionally
+ * - Subsequent calls: updates only if new SL is BETTER (protects more profit)
+ * - For LONG: only accepts HIGHER SL (never moves down, closer to entry wins)
+ * - For SHORT: only accepts LOWER SL (never moves up, closer to entry wins)
  *
  * Automatically detects backtest/live mode from execution context.
  *
  * @param symbol - Trading pair symbol
- * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+ * @param percentShift - Percentage adjustment to ORIGINAL SL distance (-100 to 100)
  * @param currentPrice - Current market price to check for intrusion
- * @returns Promise that resolves when trailing SL is updated
+ * @returns Promise<boolean> - true if trailing SL was set/updated, false if rejected (absorption/intrusion/conflict)
  *
  * @example
  * ```typescript
  * import { trailingStop } from "backtest-kit";
  *
  * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
- * // Tighten stop by 50%: newSL = 100 - 5% = 95
- * await trailingStop("BTCUSDT", -50, 102);
+ *
+ * // First call: tighten by 5%
+ * const success1 = await trailingStop("BTCUSDT", -5, 102);
+ * // success1 = true, newDistance = 10% - 5% = 5%, newSL = 95
+ *
+ * // Second call: try weaker protection (smaller percentShift)
+ * const success2 = await trailingStop("BTCUSDT", -3, 102);
+ * // success2 = false (SKIPPED: newSL=97 < 95, worse protection, larger % absorbs smaller)
+ *
+ * // Third call: stronger protection (larger percentShift)
+ * const success3 = await trailingStop("BTCUSDT", -7, 102);
+ * // success3 = true (ACCEPTED: newDistance = 10% - 7% = 3%, newSL = 97 > 95, better protection)
  * ```
  */
 async function trailingStop(symbol, percentShift, currentPrice) {
@@ -18462,46 +18623,66 @@ async function trailingStop(symbol, percentShift, currentPrice) {
     }
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
-    await bt.strategyCoreService.trailingStop(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
+    return await bt.strategyCoreService.trailingStop(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
 }
 /**
  * Adjusts the trailing take-profit distance for an active pending signal.
  *
- * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
- * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
- * Once direction is set on first call, subsequent calls must continue in same direction.
+ * CRITICAL: Always calculates from ORIGINAL TP, not from current trailing TP.
+ * This prevents error accumulation on repeated calls.
+ * Larger percentShift ABSORBS smaller one (updates only towards more conservative TP).
+ *
+ * Updates the take-profit distance by a percentage adjustment relative to the ORIGINAL TP distance.
+ * Negative percentShift brings TP closer to entry (more conservative).
+ * Positive percentShift moves TP further from entry (more aggressive).
+ *
+ * Absorption behavior:
+ * - First call: sets trailing TP unconditionally
+ * - Subsequent calls: updates only if new TP is MORE CONSERVATIVE (closer to entry)
+ * - For LONG: only accepts LOWER TP (never moves up, closer to entry wins)
+ * - For SHORT: only accepts HIGHER TP (never moves down, closer to entry wins)
  *
  * Automatically detects backtest/live mode from execution context.
  *
  * @param symbol - Trading pair symbol
- * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+ * @param percentShift - Percentage adjustment to ORIGINAL TP distance (-100 to 100)
  * @param currentPrice - Current market price to check for intrusion
- * @returns Promise that resolves when trailing TP is updated
+ * @returns Promise<boolean> - true if trailing TP was set/updated, false if rejected (absorption/intrusion/conflict)
  *
  * @example
  * ```typescript
- * import { trailingProfit } from "backtest-kit";
+ * import { trailingTake } from "backtest-kit";
  *
  * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
- * // Move TP further by 50%: newTP = 100 + 15% = 115
- * await trailingProfit("BTCUSDT", 50, 102);
+ *
+ * // First call: bring TP closer by 3%
+ * const success1 = await trailingTake("BTCUSDT", -3, 102);
+ * // success1 = true, newDistance = 10% - 3% = 7%, newTP = 107
+ *
+ * // Second call: try to move TP further (less conservative)
+ * const success2 = await trailingTake("BTCUSDT", 2, 102);
+ * // success2 = false (SKIPPED: newTP=112 > 107, less conservative, larger % absorbs smaller)
+ *
+ * // Third call: even more conservative
+ * const success3 = await trailingTake("BTCUSDT", -5, 102);
+ * // success3 = true (ACCEPTED: newDistance = 10% - 5% = 5%, newTP = 105 < 107, more conservative)
  * ```
  */
-async function trailingProfit(symbol, percentShift, currentPrice) {
+async function trailingTake(symbol, percentShift, currentPrice) {
     bt.loggerService.info(TRAILING_PROFIT_METHOD_NAME, {
         symbol,
         percentShift,
         currentPrice,
     });
     if (!ExecutionContextService.hasContext()) {
-        throw new Error("trailingProfit requires an execution context");
+        throw new Error("trailingTake requires an execution context");
     }
     if (!MethodContextService.hasContext()) {
-        throw new Error("trailingProfit requires a method context");
+        throw new Error("trailingTake requires a method context");
     }
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
-    await bt.strategyCoreService.trailingProfit(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
+    return await bt.strategyCoreService.trailingTake(isBacktest, symbol, percentShift, currentPrice, { exchangeName, frameName, strategyName });
 }
 /**
  * Moves stop-loss to breakeven when price reaches threshold.
@@ -20448,7 +20629,7 @@ const BACKTEST_METHOD_NAME_CANCEL = "BacktestUtils.cancel";
 const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.partialProfit";
 const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.partialLoss";
 const BACKTEST_METHOD_NAME_TRAILING_STOP = "BacktestUtils.trailingStop";
-const BACKTEST_METHOD_NAME_TRAILING_PROFIT = "BacktestUtils.trailingProfit";
+const BACKTEST_METHOD_NAME_TRAILING_PROFIT = "BacktestUtils.trailingTake";
 const BACKTEST_METHOD_NAME_GET_DATA = "BacktestUtils.getData";
 /**
  * Internal task function that runs backtest and handles completion.
@@ -21067,11 +21248,22 @@ class BacktestUtils {
         /**
          * Adjusts the trailing stop-loss distance for an active pending signal.
          *
-         * Updates the stop-loss distance by a percentage adjustment relative to the original SL distance.
-         * Positive percentShift tightens the SL (reduces distance), negative percentShift loosens it.
+         * CRITICAL: Always calculates from ORIGINAL SL, not from current trailing SL.
+         * This prevents error accumulation on repeated calls.
+         * Larger percentShift ABSORBS smaller one (updates only towards better protection).
+         *
+         * Updates the stop-loss distance by a percentage adjustment relative to the ORIGINAL SL distance.
+         * Negative percentShift tightens the SL (reduces distance, moves closer to entry).
+         * Positive percentShift loosens the SL (increases distance, moves away from entry).
+         *
+         * Absorption behavior:
+         * - First call: sets trailing SL unconditionally
+         * - Subsequent calls: updates only if new SL is BETTER (protects more profit)
+         * - For LONG: only accepts HIGHER SL (never moves down, closer to entry wins)
+         * - For SHORT: only accepts LOWER SL (never moves up, closer to entry wins)
          *
          * @param symbol - Trading pair symbol
-         * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+         * @param percentShift - Percentage adjustment to ORIGINAL SL distance (-100 to 100)
          * @param currentPrice - Current market price to check for intrusion
          * @param context - Execution context with strategyName, exchangeName, and frameName
          * @returns Promise that resolves when trailing SL is updated
@@ -21079,12 +21271,22 @@ class BacktestUtils {
          * @example
          * ```typescript
          * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
-         * // Tighten stop by 50%: newSL = 100 - 5% = 95
-         * await Backtest.trailingStop("BTCUSDT", -50, 102, {
+         *
+         * // First call: tighten by 5%
+         * await Backtest.trailingStop("BTCUSDT", -5, 102, {
          *   exchangeName: "binance",
          *   frameName: "frame1",
          *   strategyName: "my-strategy"
          * });
+         * // newDistance = 10% - 5% = 5%, newSL = 95
+         *
+         * // Second call: try weaker protection (smaller percentShift)
+         * await Backtest.trailingStop("BTCUSDT", -3, 102, context);
+         * // SKIPPED: newSL=97 < 95 (worse protection, larger % absorbs smaller)
+         *
+         * // Third call: stronger protection (larger percentShift)
+         * await Backtest.trailingStop("BTCUSDT", -7, 102, context);
+         * // ACCEPTED: newDistance = 10% - 7% = 3%, newSL = 97 > 95 (better protection)
          * ```
          */
         this.trailingStop = async (symbol, percentShift, currentPrice, context) => {
@@ -21103,17 +21305,27 @@ class BacktestUtils {
                 riskList &&
                     riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_TRAILING_STOP));
             }
-            await bt.strategyCoreService.trailingStop(true, symbol, percentShift, currentPrice, context);
+            return await bt.strategyCoreService.trailingStop(true, symbol, percentShift, currentPrice, context);
         };
         /**
          * Adjusts the trailing take-profit distance for an active pending signal.
          *
-         * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
-         * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
-         * Once direction is set on first call, subsequent calls must continue in same direction.
+         * CRITICAL: Always calculates from ORIGINAL TP, not from current trailing TP.
+         * This prevents error accumulation on repeated calls.
+         * Larger percentShift ABSORBS smaller one (updates only towards more conservative TP).
+         *
+         * Updates the take-profit distance by a percentage adjustment relative to the ORIGINAL TP distance.
+         * Negative percentShift brings TP closer to entry (more conservative).
+         * Positive percentShift moves TP further from entry (more aggressive).
+         *
+         * Absorption behavior:
+         * - First call: sets trailing TP unconditionally
+         * - Subsequent calls: updates only if new TP is MORE CONSERVATIVE (closer to entry)
+         * - For LONG: only accepts LOWER TP (never moves up, closer to entry wins)
+         * - For SHORT: only accepts HIGHER TP (never moves down, closer to entry wins)
          *
          * @param symbol - Trading pair symbol
-         * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+         * @param percentShift - Percentage adjustment to ORIGINAL TP distance (-100 to 100)
          * @param currentPrice - Current market price to check for intrusion
          * @param context - Execution context with strategyName, exchangeName, and frameName
          * @returns Promise that resolves when trailing TP is updated
@@ -21121,15 +21333,25 @@ class BacktestUtils {
          * @example
          * ```typescript
          * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
-         * // Move TP further by 50%: newTP = 100 + 15% = 115
-         * await Backtest.trailingProfit("BTCUSDT", 50, 102, {
+         *
+         * // First call: bring TP closer by 3%
+         * await Backtest.trailingTake("BTCUSDT", -3, 102, {
          *   exchangeName: "binance",
          *   frameName: "frame1",
          *   strategyName: "my-strategy"
          * });
+         * // newDistance = 10% - 3% = 7%, newTP = 107
+         *
+         * // Second call: try to move TP further (less conservative)
+         * await Backtest.trailingTake("BTCUSDT", 2, 102, context);
+         * // SKIPPED: newTP=112 > 107 (less conservative, larger % absorbs smaller)
+         *
+         * // Third call: even more conservative
+         * await Backtest.trailingTake("BTCUSDT", -5, 102, context);
+         * // ACCEPTED: newDistance = 10% - 5% = 5%, newTP = 105 < 107 (more conservative)
          * ```
          */
-        this.trailingProfit = async (symbol, percentShift, currentPrice, context) => {
+        this.trailingTake = async (symbol, percentShift, currentPrice, context) => {
             bt.loggerService.info(BACKTEST_METHOD_NAME_TRAILING_PROFIT, {
                 symbol,
                 percentShift,
@@ -21145,7 +21367,7 @@ class BacktestUtils {
                 riskList &&
                     riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_TRAILING_PROFIT));
             }
-            await bt.strategyCoreService.trailingProfit(true, symbol, percentShift, currentPrice, context);
+            return await bt.strategyCoreService.trailingTake(true, symbol, percentShift, currentPrice, context);
         };
         /**
          * Moves stop-loss to breakeven when price reaches threshold.
@@ -21351,7 +21573,7 @@ const LIVE_METHOD_NAME_CANCEL = "LiveUtils.cancel";
 const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.partialProfit";
 const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.partialLoss";
 const LIVE_METHOD_NAME_TRAILING_STOP = "LiveUtils.trailingStop";
-const LIVE_METHOD_NAME_TRAILING_PROFIT = "LiveUtils.trailingProfit";
+const LIVE_METHOD_NAME_TRAILING_PROFIT = "LiveUtils.trailingTake";
 /**
  * Internal task function that runs live trading and handles completion.
  * Consumes live trading results and updates instance state flags.
@@ -21947,23 +22169,44 @@ class LiveUtils {
         /**
          * Adjusts the trailing stop-loss distance for an active pending signal.
          *
-         * Updates the stop-loss distance by a percentage adjustment relative to the original SL distance.
-         * Positive percentShift tightens the SL (reduces distance), negative percentShift loosens it.
+         * CRITICAL: Always calculates from ORIGINAL SL, not from current trailing SL.
+         * This prevents error accumulation on repeated calls.
+         * Larger percentShift ABSORBS smaller one (updates only towards better protection).
+         *
+         * Updates the stop-loss distance by a percentage adjustment relative to the ORIGINAL SL distance.
+         * Negative percentShift tightens the SL (reduces distance, moves closer to entry).
+         * Positive percentShift loosens the SL (increases distance, moves away from entry).
+         *
+         * Absorption behavior:
+         * - First call: sets trailing SL unconditionally
+         * - Subsequent calls: updates only if new SL is BETTER (protects more profit)
+         * - For LONG: only accepts HIGHER SL (never moves down, closer to entry wins)
+         * - For SHORT: only accepts LOWER SL (never moves up, closer to entry wins)
          *
          * @param symbol - Trading pair symbol
-         * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+         * @param percentShift - Percentage adjustment to ORIGINAL SL distance (-100 to 100)
          * @param currentPrice - Current market price to check for intrusion
          * @param context - Execution context with strategyName and exchangeName
-         * @returns Promise that resolves when trailing SL is updated
+         * @returns Promise<boolean> - true if trailing SL was set/updated, false if rejected (absorption/intrusion/conflict)
          *
          * @example
          * ```typescript
          * // LONG: entry=100, originalSL=90, distance=10%, currentPrice=102
-         * // Tighten stop by 50%: newSL = 100 - 5% = 95
-         * await Live.trailingStop("BTCUSDT", -50, 102, {
+         *
+         * // First call: tighten by 5%
+         * const success1 = await Live.trailingStop("BTCUSDT", -5, 102, {
          *   exchangeName: "binance",
          *   strategyName: "my-strategy"
          * });
+         * // success1 = true, newDistance = 10% - 5% = 5%, newSL = 95
+         *
+         * // Second call: try weaker protection (smaller percentShift)
+         * const success2 = await Live.trailingStop("BTCUSDT", -3, 102, context);
+         * // success2 = false (SKIPPED: newSL=97 < 95, worse protection, larger % absorbs smaller)
+         *
+         * // Third call: stronger protection (larger percentShift)
+         * const success3 = await Live.trailingStop("BTCUSDT", -7, 102, context);
+         * // success3 = true (ACCEPTED: newDistance = 10% - 7% = 3%, newSL = 97 > 95, better protection)
          * ```
          */
         this.trailingStop = async (symbol, percentShift, currentPrice, context) => {
@@ -21980,7 +22223,7 @@ class LiveUtils {
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_STOP);
                 riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_STOP));
             }
-            await bt.strategyCoreService.trailingStop(false, symbol, percentShift, currentPrice, {
+            return await bt.strategyCoreService.trailingStop(false, symbol, percentShift, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -21989,27 +22232,47 @@ class LiveUtils {
         /**
          * Adjusts the trailing take-profit distance for an active pending signal.
          *
-         * Updates the take-profit distance by a percentage adjustment relative to the original TP distance.
-         * Negative percentShift brings TP closer to entry, positive percentShift moves it further.
-         * Once direction is set on first call, subsequent calls must continue in same direction.
+         * CRITICAL: Always calculates from ORIGINAL TP, not from current trailing TP.
+         * This prevents error accumulation on repeated calls.
+         * Larger percentShift ABSORBS smaller one (updates only towards more conservative TP).
+         *
+         * Updates the take-profit distance by a percentage adjustment relative to the ORIGINAL TP distance.
+         * Negative percentShift brings TP closer to entry (more conservative).
+         * Positive percentShift moves TP further from entry (more aggressive).
+         *
+         * Absorption behavior:
+         * - First call: sets trailing TP unconditionally
+         * - Subsequent calls: updates only if new TP is MORE CONSERVATIVE (closer to entry)
+         * - For LONG: only accepts LOWER TP (never moves up, closer to entry wins)
+         * - For SHORT: only accepts HIGHER TP (never moves down, closer to entry wins)
          *
          * @param symbol - Trading pair symbol
-         * @param percentShift - Percentage adjustment to TP distance (-100 to 100)
+         * @param percentShift - Percentage adjustment to ORIGINAL TP distance (-100 to 100)
          * @param currentPrice - Current market price to check for intrusion
          * @param context - Execution context with strategyName and exchangeName
-         * @returns Promise that resolves when trailing TP is updated
+         * @returns Promise<boolean> - true if trailing TP was set/updated, false if rejected (absorption/intrusion/conflict)
          *
          * @example
          * ```typescript
          * // LONG: entry=100, originalTP=110, distance=10%, currentPrice=102
-         * // Move TP further by 50%: newTP = 100 + 15% = 115
-         * await Live.trailingProfit("BTCUSDT", 50, 102, {
+         *
+         * // First call: bring TP closer by 3%
+         * const success1 = await Live.trailingTake("BTCUSDT", -3, 102, {
          *   exchangeName: "binance",
          *   strategyName: "my-strategy"
          * });
+         * // success1 = true, newDistance = 10% - 3% = 7%, newTP = 107
+         *
+         * // Second call: try to move TP further (less conservative)
+         * const success2 = await Live.trailingTake("BTCUSDT", 2, 102, context);
+         * // success2 = false (SKIPPED: newTP=112 > 107, less conservative, larger % absorbs smaller)
+         *
+         * // Third call: even more conservative
+         * const success3 = await Live.trailingTake("BTCUSDT", -5, 102, context);
+         * // success3 = true (ACCEPTED: newDistance = 10% - 5% = 5%, newTP = 105 < 107, more conservative)
          * ```
          */
-        this.trailingProfit = async (symbol, percentShift, currentPrice, context) => {
+        this.trailingTake = async (symbol, percentShift, currentPrice, context) => {
             bt.loggerService.info(LIVE_METHOD_NAME_TRAILING_PROFIT, {
                 symbol,
                 percentShift,
@@ -22023,7 +22286,7 @@ class LiveUtils {
                 riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_PROFIT);
                 riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_PROFIT));
             }
-            await bt.strategyCoreService.trailingProfit(false, symbol, percentShift, currentPrice, {
+            return await bt.strategyCoreService.trailingTake(false, symbol, percentShift, currentPrice, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -22262,6 +22525,7 @@ class ScheduleUtils {
             });
             bt.strategyValidationService.validate(context.strategyName, SCHEDULE_METHOD_NAME_GET_DATA);
             bt.exchangeValidationService.validate(context.exchangeName, SCHEDULE_METHOD_NAME_GET_DATA);
+            context.frameName && bt.frameValidationService.validate(context.frameName, SCHEDULE_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_DATA);
@@ -22291,6 +22555,7 @@ class ScheduleUtils {
             });
             bt.strategyValidationService.validate(context.strategyName, SCHEDULE_METHOD_NAME_GET_REPORT);
             bt.exchangeValidationService.validate(context.exchangeName, SCHEDULE_METHOD_NAME_GET_REPORT);
+            context.frameName && bt.frameValidationService.validate(context.frameName, SCHEDULE_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT);
@@ -22324,6 +22589,7 @@ class ScheduleUtils {
             });
             bt.strategyValidationService.validate(context.strategyName, SCHEDULE_METHOD_NAME_DUMP);
             bt.exchangeValidationService.validate(context.exchangeName, SCHEDULE_METHOD_NAME_DUMP);
+            context.frameName && bt.frameValidationService.validate(context.frameName, SCHEDULE_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP);
@@ -22413,6 +22679,7 @@ class Performance {
     static async getData(symbol, context, backtest = false) {
         bt.strategyValidationService.validate(context.strategyName, PERFORMANCE_METHOD_NAME_GET_DATA);
         bt.exchangeValidationService.validate(context.exchangeName, PERFORMANCE_METHOD_NAME_GET_DATA);
+        context.frameName && bt.frameValidationService.validate(context.frameName, PERFORMANCE_METHOD_NAME_GET_DATA);
         {
             const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
             riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_DATA);
@@ -22446,6 +22713,7 @@ class Performance {
     static async getReport(symbol, context, backtest = false, columns) {
         bt.strategyValidationService.validate(context.strategyName, PERFORMANCE_METHOD_NAME_GET_REPORT);
         bt.exchangeValidationService.validate(context.exchangeName, PERFORMANCE_METHOD_NAME_GET_REPORT);
+        context.frameName && bt.frameValidationService.validate(context.frameName, PERFORMANCE_METHOD_NAME_GET_REPORT);
         {
             const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
             riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT);
@@ -22476,6 +22744,7 @@ class Performance {
     static async dump(symbol, context, backtest = false, path = "./dump/performance", columns) {
         bt.strategyValidationService.validate(context.strategyName, PERFORMANCE_METHOD_NAME_DUMP);
         bt.exchangeValidationService.validate(context.exchangeName, PERFORMANCE_METHOD_NAME_DUMP);
+        context.frameName && bt.frameValidationService.validate(context.frameName, PERFORMANCE_METHOD_NAME_DUMP);
         {
             const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
             riskName && bt.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP);
@@ -23067,6 +23336,7 @@ class HeatUtils {
             bt.loggerService.info(HEAT_METHOD_NAME_GET_DATA, { strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, HEAT_METHOD_NAME_GET_DATA);
             bt.exchangeValidationService.validate(context.exchangeName, HEAT_METHOD_NAME_GET_DATA);
+            context.frameName && bt.frameValidationService.validate(context.frameName, HEAT_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_DATA);
@@ -23109,6 +23379,7 @@ class HeatUtils {
             bt.loggerService.info(HEAT_METHOD_NAME_GET_REPORT, { strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, HEAT_METHOD_NAME_GET_REPORT);
             bt.exchangeValidationService.validate(context.exchangeName, HEAT_METHOD_NAME_GET_REPORT);
+            context.frameName && bt.frameValidationService.validate(context.frameName, HEAT_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT);
@@ -23148,6 +23419,7 @@ class HeatUtils {
             bt.loggerService.info(HEAT_METHOD_NAME_DUMP, { strategyName: context.strategyName, path });
             bt.strategyValidationService.validate(context.strategyName, HEAT_METHOD_NAME_DUMP);
             bt.exchangeValidationService.validate(context.exchangeName, HEAT_METHOD_NAME_DUMP);
+            context.frameName && bt.frameValidationService.validate(context.frameName, HEAT_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP);
@@ -23481,6 +23753,7 @@ class PartialUtils {
             bt.loggerService.info(PARTIAL_METHOD_NAME_GET_DATA, { symbol, strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, PARTIAL_METHOD_NAME_GET_DATA);
             bt.exchangeValidationService.validate(context.exchangeName, PARTIAL_METHOD_NAME_GET_DATA);
+            context.frameName && bt.frameValidationService.validate(context.frameName, PARTIAL_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_DATA);
@@ -23531,6 +23804,7 @@ class PartialUtils {
             bt.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol, strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, PARTIAL_METHOD_NAME_GET_REPORT);
             bt.exchangeValidationService.validate(context.exchangeName, PARTIAL_METHOD_NAME_GET_REPORT);
+            context.frameName && bt.frameValidationService.validate(context.frameName, PARTIAL_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT);
@@ -23574,6 +23848,7 @@ class PartialUtils {
             bt.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, strategyName: context.strategyName, path });
             bt.strategyValidationService.validate(context.strategyName, PARTIAL_METHOD_NAME_DUMP);
             bt.exchangeValidationService.validate(context.exchangeName, PARTIAL_METHOD_NAME_DUMP);
+            context.frameName && bt.frameValidationService.validate(context.frameName, PARTIAL_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP);
@@ -24764,6 +25039,7 @@ class BreakevenUtils {
             bt.loggerService.info(BREAKEVEN_METHOD_NAME_GET_DATA, { symbol, strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, BREAKEVEN_METHOD_NAME_GET_DATA);
             bt.exchangeValidationService.validate(context.exchangeName, BREAKEVEN_METHOD_NAME_GET_DATA);
+            context.frameName && bt.frameValidationService.validate(context.frameName, BREAKEVEN_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, BREAKEVEN_METHOD_NAME_GET_DATA);
@@ -24810,6 +25086,7 @@ class BreakevenUtils {
             bt.loggerService.info(BREAKEVEN_METHOD_NAME_GET_REPORT, { symbol, strategyName: context.strategyName });
             bt.strategyValidationService.validate(context.strategyName, BREAKEVEN_METHOD_NAME_GET_REPORT);
             bt.exchangeValidationService.validate(context.exchangeName, BREAKEVEN_METHOD_NAME_GET_REPORT);
+            context.frameName && bt.frameValidationService.validate(context.frameName, BREAKEVEN_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, BREAKEVEN_METHOD_NAME_GET_REPORT);
@@ -24853,6 +25130,7 @@ class BreakevenUtils {
             bt.loggerService.info(BREAKEVEN_METHOD_NAME_DUMP, { symbol, strategyName: context.strategyName, path });
             bt.strategyValidationService.validate(context.strategyName, BREAKEVEN_METHOD_NAME_DUMP);
             bt.exchangeValidationService.validate(context.exchangeName, BREAKEVEN_METHOD_NAME_DUMP);
+            context.frameName && bt.frameValidationService.validate(context.frameName, BREAKEVEN_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = bt.strategySchemaService.get(context.strategyName);
                 riskName && bt.riskValidationService.validate(riskName, BREAKEVEN_METHOD_NAME_DUMP);
@@ -24969,6 +25247,6 @@ exports.setColumns = setColumns;
 exports.setConfig = setConfig;
 exports.setLogger = setLogger;
 exports.stop = stop;
-exports.trailingProfit = trailingProfit;
 exports.trailingStop = trailingStop;
+exports.trailingTake = trailingTake;
 exports.validate = validate;