backtest-kit 1.8.1 → 1.9.1

package/build/index.cjs

@@ -363,6 +363,136 @@ const GLOBAL_CONFIG = {
 };
 const DEFAULT_CONFIG = Object.freeze({ ...GLOBAL_CONFIG });
 
+/**
+ * Global signal emitter for all trading events (live + backtest).
+ * Emits all signal events regardless of execution mode.
+ */
+const signalEmitter = new functoolsKit.Subject();
+/**
+ * Live trading signal emitter.
+ * Emits only signals from live trading execution.
+ */
+const signalLiveEmitter = new functoolsKit.Subject();
+/**
+ * Backtest signal emitter.
+ * Emits only signals from backtest execution.
+ */
+const signalBacktestEmitter = new functoolsKit.Subject();
+/**
+ * Error emitter for background execution errors.
+ * Emits errors caught in background tasks (Live.background, Backtest.background).
+ */
+const errorEmitter = new functoolsKit.Subject();
+/**
+ * Exit emitter for critical errors that require process termination.
+ * Emits errors that should terminate the current execution (Backtest, Live, Walker).
+ * Unlike errorEmitter (for recoverable errors), exitEmitter signals fatal errors.
+ */
+const exitEmitter = new functoolsKit.Subject();
+/**
+ * Done emitter for live background execution completion.
+ * Emits when live background tasks complete (Live.background).
+ */
+const doneLiveSubject = new functoolsKit.Subject();
+/**
+ * Done emitter for backtest background execution completion.
+ * Emits when backtest background tasks complete (Backtest.background).
+ */
+const doneBacktestSubject = new functoolsKit.Subject();
+/**
+ * Done emitter for walker background execution completion.
+ * Emits when walker background tasks complete (Walker.background).
+ */
+const doneWalkerSubject = new functoolsKit.Subject();
+/**
+ * Progress emitter for backtest execution progress.
+ * Emits progress updates during backtest execution.
+ */
+const progressBacktestEmitter = new functoolsKit.Subject();
+/**
+ * Progress emitter for walker execution progress.
+ * Emits progress updates during walker execution.
+ */
+const progressWalkerEmitter = new functoolsKit.Subject();
+/**
+ * Progress emitter for optimizer execution progress.
+ * Emits progress updates during optimizer execution.
+ */
+const progressOptimizerEmitter = new functoolsKit.Subject();
+/**
+ * Performance emitter for execution metrics.
+ * Emits performance metrics for profiling and bottleneck detection.
+ */
+const performanceEmitter = new functoolsKit.Subject();
+/**
+ * Walker emitter for strategy comparison progress.
+ * Emits progress updates during walker execution (each strategy completion).
+ */
+const walkerEmitter = new functoolsKit.Subject();
+/**
+ * Walker complete emitter for strategy comparison completion.
+ * Emits when all strategies have been tested and final results are available.
+ */
+const walkerCompleteSubject = new functoolsKit.Subject();
+/**
+ * Walker stop emitter for walker cancellation events.
+ * Emits when a walker comparison is stopped/cancelled.
+ *
+ * Includes walkerName to support multiple walkers running on the same symbol.
+ */
+const walkerStopSubject = new functoolsKit.Subject();
+/**
+ * Validation emitter for risk validation errors.
+ * Emits when risk validation functions throw errors during signal checking.
+ */
+const validationSubject = new functoolsKit.Subject();
+/**
+ * Partial profit emitter for profit level milestones.
+ * Emits when a signal reaches a profit level (10%, 20%, 30%, etc).
+ */
+const partialProfitSubject = new functoolsKit.Subject();
+/**
+ * Partial loss emitter for loss level milestones.
+ * Emits when a signal reaches a loss level (10%, 20%, 30%, etc).
+ */
+const partialLossSubject = new functoolsKit.Subject();
+/**
+ * Risk rejection emitter for risk management violations.
+ * Emits ONLY when a signal is rejected due to risk validation failure.
+ * Does not emit for allowed signals (prevents spam).
+ */
+const riskSubject = new functoolsKit.Subject();
+/**
+ * Ping emitter for scheduled signal monitoring events.
+ * Emits every minute when a scheduled signal is being monitored (waiting for activation).
+ * Allows users to track scheduled signal lifecycle and implement custom cancellation logic.
+ */
+const pingSubject = new functoolsKit.Subject();
+
+var emitters = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    doneBacktestSubject: doneBacktestSubject,
+    doneLiveSubject: doneLiveSubject,
+    doneWalkerSubject: doneWalkerSubject,
+    errorEmitter: errorEmitter,
+    exitEmitter: exitEmitter,
+    partialLossSubject: partialLossSubject,
+    partialProfitSubject: partialProfitSubject,
+    performanceEmitter: performanceEmitter,
+    pingSubject: pingSubject,
+    progressBacktestEmitter: progressBacktestEmitter,
+    progressOptimizerEmitter: progressOptimizerEmitter,
+    progressWalkerEmitter: progressWalkerEmitter,
+    riskSubject: riskSubject,
+    signalBacktestEmitter: signalBacktestEmitter,
+    signalEmitter: signalEmitter,
+    signalLiveEmitter: signalLiveEmitter,
+    validationSubject: validationSubject,
+    walkerCompleteSubject: walkerCompleteSubject,
+    walkerEmitter: walkerEmitter,
+    walkerStopSubject: walkerStopSubject
+});
+
 const INTERVAL_MINUTES$4 = {
     "1m": 1,
     "3m": 3,
@@ -464,6 +594,33 @@ const GET_CANDLES_FN = async (dto, since, self) => {
     }
     throw lastError;
 };
+/**
+ * Wrapper to call onCandleData callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param self - ClientExchange instance reference
+ * @param symbol - Trading pair symbol
+ * @param interval - Candle interval
+ * @param since - Start date for candle data
+ * @param limit - Number of candles
+ * @param data - Array of candle data
+ */
+const CALL_CANDLE_DATA_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, interval, since, limit, data) => {
+    if (self.params.callbacks?.onCandleData) {
+        await self.params.callbacks.onCandleData(symbol, interval, since, limit, data);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientExchange CALL_CANDLE_DATA_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Client implementation for exchange data access.
  *
@@ -522,9 +679,7 @@ class ClientExchange {
         if (filteredData.length < limit) {
             this.params.logger.warn(`ClientExchange Expected ${limit} candles, got ${filteredData.length}`);
         }
-        if (this.params.callbacks?.onCandleData) {
-            this.params.callbacks.onCandleData(symbol, interval, since, limit, filteredData);
-        }
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, filteredData);
         return filteredData;
     }
     /**
@@ -559,9 +714,7 @@ class ClientExchange {
         if (filteredData.length < limit) {
             this.params.logger.warn(`ClientExchange getNextCandles: Expected ${limit} candles, got ${filteredData.length}`);
         }
-        if (this.params.callbacks?.onCandleData) {
-            this.params.callbacks.onCandleData(symbol, interval, since, limit, filteredData);
-        }
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, filteredData);
         return filteredData;
     }
     /**
@@ -1738,136 +1891,6 @@ class PersistPartialUtils {
  */
 const PersistPartialAdapter = new PersistPartialUtils();
 
-/**
- * Global signal emitter for all trading events (live + backtest).
- * Emits all signal events regardless of execution mode.
- */
-const signalEmitter = new functoolsKit.Subject();
-/**
- * Live trading signal emitter.
- * Emits only signals from live trading execution.
- */
-const signalLiveEmitter = new functoolsKit.Subject();
-/**
- * Backtest signal emitter.
- * Emits only signals from backtest execution.
- */
-const signalBacktestEmitter = new functoolsKit.Subject();
-/**
- * Error emitter for background execution errors.
- * Emits errors caught in background tasks (Live.background, Backtest.background).
- */
-const errorEmitter = new functoolsKit.Subject();
-/**
- * Exit emitter for critical errors that require process termination.
- * Emits errors that should terminate the current execution (Backtest, Live, Walker).
- * Unlike errorEmitter (for recoverable errors), exitEmitter signals fatal errors.
- */
-const exitEmitter = new functoolsKit.Subject();
-/**
- * Done emitter for live background execution completion.
- * Emits when live background tasks complete (Live.background).
- */
-const doneLiveSubject = new functoolsKit.Subject();
-/**
- * Done emitter for backtest background execution completion.
- * Emits when backtest background tasks complete (Backtest.background).
- */
-const doneBacktestSubject = new functoolsKit.Subject();
-/**
- * Done emitter for walker background execution completion.
- * Emits when walker background tasks complete (Walker.background).
- */
-const doneWalkerSubject = new functoolsKit.Subject();
-/**
- * Progress emitter for backtest execution progress.
- * Emits progress updates during backtest execution.
- */
-const progressBacktestEmitter = new functoolsKit.Subject();
-/**
- * Progress emitter for walker execution progress.
- * Emits progress updates during walker execution.
- */
-const progressWalkerEmitter = new functoolsKit.Subject();
-/**
- * Progress emitter for optimizer execution progress.
- * Emits progress updates during optimizer execution.
- */
-const progressOptimizerEmitter = new functoolsKit.Subject();
-/**
- * Performance emitter for execution metrics.
- * Emits performance metrics for profiling and bottleneck detection.
- */
-const performanceEmitter = new functoolsKit.Subject();
-/**
- * Walker emitter for strategy comparison progress.
- * Emits progress updates during walker execution (each strategy completion).
- */
-const walkerEmitter = new functoolsKit.Subject();
-/**
- * Walker complete emitter for strategy comparison completion.
- * Emits when all strategies have been tested and final results are available.
- */
-const walkerCompleteSubject = new functoolsKit.Subject();
-/**
- * Walker stop emitter for walker cancellation events.
- * Emits when a walker comparison is stopped/cancelled.
- *
- * Includes walkerName to support multiple walkers running on the same symbol.
- */
-const walkerStopSubject = new functoolsKit.Subject();
-/**
- * Validation emitter for risk validation errors.
- * Emits when risk validation functions throw errors during signal checking.
- */
-const validationSubject = new functoolsKit.Subject();
-/**
- * Partial profit emitter for profit level milestones.
- * Emits when a signal reaches a profit level (10%, 20%, 30%, etc).
- */
-const partialProfitSubject = new functoolsKit.Subject();
-/**
- * Partial loss emitter for loss level milestones.
- * Emits when a signal reaches a loss level (10%, 20%, 30%, etc).
- */
-const partialLossSubject = new functoolsKit.Subject();
-/**
- * Risk rejection emitter for risk management violations.
- * Emits ONLY when a signal is rejected due to risk validation failure.
- * Does not emit for allowed signals (prevents spam).
- */
-const riskSubject = new functoolsKit.Subject();
-/**
- * Ping emitter for scheduled signal monitoring events.
- * Emits every minute when a scheduled signal is being monitored (waiting for activation).
- * Allows users to track scheduled signal lifecycle and implement custom cancellation logic.
- */
-const pingSubject = new functoolsKit.Subject();
-
-var emitters = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    doneBacktestSubject: doneBacktestSubject,
-    doneLiveSubject: doneLiveSubject,
-    doneWalkerSubject: doneWalkerSubject,
-    errorEmitter: errorEmitter,
-    exitEmitter: exitEmitter,
-    partialLossSubject: partialLossSubject,
-    partialProfitSubject: partialProfitSubject,
-    performanceEmitter: performanceEmitter,
-    pingSubject: pingSubject,
-    progressBacktestEmitter: progressBacktestEmitter,
-    progressOptimizerEmitter: progressOptimizerEmitter,
-    progressWalkerEmitter: progressWalkerEmitter,
-    riskSubject: riskSubject,
-    signalBacktestEmitter: signalBacktestEmitter,
-    signalEmitter: signalEmitter,
-    signalLiveEmitter: signalLiveEmitter,
-    validationSubject: validationSubject,
-    walkerCompleteSubject: walkerCompleteSubject,
-    walkerEmitter: walkerEmitter,
-    walkerStopSubject: walkerStopSubject
-});
-
 /**
  * Converts markdown content to plain text with minimal formatting
  * @param content - Markdown string to convert
@@ -1924,227 +1947,321 @@ const INTERVAL_MINUTES$3 = {
     "1h": 60,
 };
 const TIMEOUT_SYMBOL = Symbol('timeout');
+/**
+ * Converts internal signal to public API format.
+ *
+ * This function is used AFTER position opens for external callbacks and API.
+ * It hides internal implementation details while exposing effective values:
+ *
+ * - Replaces internal _trailingPriceStopLoss with effective priceStopLoss
+ * - Preserves original stop-loss in originalPriceStopLoss for reference
+ * - Ensures external code never sees private _trailingPriceStopLoss field
+ * - Maintains backward compatibility with non-trailing positions
+ *
+ * Key differences from TO_RISK_SIGNAL (in ClientRisk.ts):
+ * - Used AFTER position opens (vs BEFORE for risk validation)
+ * - Works only with ISignalRow/IScheduledSignalRow (vs ISignalDto)
+ * - No currentPrice fallback needed (priceOpen always present in opened signals)
+ * - Returns IPublicSignalRow (vs IRiskSignalRow for risk checks)
+ *
+ * Use cases:
+ * - All strategy callbacks (onOpen, onClose, onActive, etc.)
+ * - External API responses (getPendingSignal, getScheduledSignal)
+ * - Event emissions and logging
+ * - Integration with ClientPartial and ClientRisk
+ *
+ * @param signal - Internal signal row with optional trailing stop-loss
+ * @returns Signal in IPublicSignalRow format with effective stop-loss and hidden internals
+ *
+ * @example
+ * ```typescript
+ * // Signal without trailing SL
+ * const publicSignal = TO_PUBLIC_SIGNAL(signal);
+ * // publicSignal.priceStopLoss = signal.priceStopLoss
+ * // publicSignal.originalPriceStopLoss = signal.priceStopLoss
+ *
+ * // Signal with trailing SL
+ * const publicSignal = TO_PUBLIC_SIGNAL(signalWithTrailing);
+ * // publicSignal.priceStopLoss = signal._trailingPriceStopLoss (effective)
+ * // publicSignal.originalPriceStopLoss = signal.priceStopLoss (original)
+ * // publicSignal._trailingPriceStopLoss = undefined (hidden from external API)
+ * ```
+ */
+const TO_PUBLIC_SIGNAL = (signal) => {
+    if (signal._trailingPriceStopLoss !== undefined) {
+        return {
+            ...signal,
+            priceStopLoss: signal._trailingPriceStopLoss,
+            originalPriceStopLoss: signal.priceStopLoss,
+        };
+    }
+    return {
+        ...signal,
+        originalPriceStopLoss: signal.priceStopLoss,
+    };
+};
 const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
     const errors = [];
     // ПРОВЕРКА ОБЯЗАТЕЛЬНЫХ ПОЛЕЙ ISignalRow
-    if (signal.id === undefined || signal.id === null || signal.id === '') {
-        errors.push('id is required and must be a non-empty string');
-    }
-    if (signal.exchangeName === undefined || signal.exchangeName === null || signal.exchangeName === '') {
-        errors.push('exchangeName is required');
-    }
-    if (signal.strategyName === undefined || signal.strategyName === null || signal.strategyName === '') {
-        errors.push('strategyName is required');
-    }
-    if (signal.symbol === undefined || signal.symbol === null || signal.symbol === '') {
-        errors.push('symbol is required and must be a non-empty string');
-    }
-    if (signal._isScheduled === undefined || signal._isScheduled === null) {
-        errors.push('_isScheduled is required');
-    }
-    if (signal.position === undefined || signal.position === null) {
-        errors.push('position is required and must be "long" or "short"');
-    }
-    if (signal.position !== "long" && signal.position !== "short") {
-        errors.push(`position must be "long" or "short", got "${signal.position}"`);
+    {
+        if (signal.id === undefined || signal.id === null || signal.id === '') {
+            errors.push('id is required and must be a non-empty string');
+        }
+        if (signal.exchangeName === undefined || signal.exchangeName === null || signal.exchangeName === '') {
+            errors.push('exchangeName is required');
+        }
+        if (signal.strategyName === undefined || signal.strategyName === null || signal.strategyName === '') {
+            errors.push('strategyName is required');
+        }
+        if (signal.symbol === undefined || signal.symbol === null || signal.symbol === '') {
+            errors.push('symbol is required and must be a non-empty string');
+        }
+        if (signal._isScheduled === undefined || signal._isScheduled === null) {
+            errors.push('_isScheduled is required');
+        }
+        if (signal.position === undefined || signal.position === null) {
+            errors.push('position is required and must be "long" or "short"');
+        }
+        if (signal.position !== "long" && signal.position !== "short") {
+            errors.push(`position must be "long" or "short", got "${signal.position}"`);
+        }
     }
     // ЗАЩИТА ОТ NaN/Infinity: currentPrice должна быть конечным числом
-    if (typeof currentPrice !== "number") {
-        errors.push(`currentPrice must be a number type, got ${currentPrice} (${typeof currentPrice})`);
-    }
-    if (!isFinite(currentPrice)) {
-        errors.push(`currentPrice must be a finite number, got ${currentPrice} (${typeof currentPrice})`);
-    }
-    if (isFinite(currentPrice) && currentPrice <= 0) {
-        errors.push(`currentPrice must be positive, got ${currentPrice}`);
+    {
+        if (typeof currentPrice !== "number") {
+            errors.push(`currentPrice must be a number type, got ${currentPrice} (${typeof currentPrice})`);
+        }
+        if (!isFinite(currentPrice)) {
+            errors.push(`currentPrice must be a finite number, got ${currentPrice} (${typeof currentPrice})`);
+        }
+        if (isFinite(currentPrice) && currentPrice <= 0) {
+            errors.push(`currentPrice must be positive, got ${currentPrice}`);
+        }
     }
     // ЗАЩИТА ОТ NaN/Infinity: все цены должны быть конечными числами
-    if (typeof signal.priceOpen !== "number") {
-        errors.push(`priceOpen must be a number type, got ${signal.priceOpen} (${typeof signal.priceOpen})`);
-    }
-    if (!isFinite(signal.priceOpen)) {
-        errors.push(`priceOpen must be a finite number, got ${signal.priceOpen} (${typeof signal.priceOpen})`);
-    }
-    if (typeof signal.priceTakeProfit !== "number") {
-        errors.push(`priceTakeProfit must be a number type, got ${signal.priceTakeProfit} (${typeof signal.priceTakeProfit})`);
-    }
-    if (!isFinite(signal.priceTakeProfit)) {
-        errors.push(`priceTakeProfit must be a finite number, got ${signal.priceTakeProfit} (${typeof signal.priceTakeProfit})`);
-    }
-    if (typeof signal.priceStopLoss !== "number") {
-        errors.push(`priceStopLoss must be a number type, got ${signal.priceStopLoss} (${typeof signal.priceStopLoss})`);
-    }
-    if (!isFinite(signal.priceStopLoss)) {
-        errors.push(`priceStopLoss must be a finite number, got ${signal.priceStopLoss} (${typeof signal.priceStopLoss})`);
+    {
+        if (typeof signal.priceOpen !== "number") {
+            errors.push(`priceOpen must be a number type, got ${signal.priceOpen} (${typeof signal.priceOpen})`);
+        }
+        if (!isFinite(signal.priceOpen)) {
+            errors.push(`priceOpen must be a finite number, got ${signal.priceOpen} (${typeof signal.priceOpen})`);
+        }
+        if (typeof signal.priceTakeProfit !== "number") {
+            errors.push(`priceTakeProfit must be a number type, got ${signal.priceTakeProfit} (${typeof signal.priceTakeProfit})`);
+        }
+        if (!isFinite(signal.priceTakeProfit)) {
+            errors.push(`priceTakeProfit must be a finite number, got ${signal.priceTakeProfit} (${typeof signal.priceTakeProfit})`);
+        }
+        if (typeof signal.priceStopLoss !== "number") {
+            errors.push(`priceStopLoss must be a number type, got ${signal.priceStopLoss} (${typeof signal.priceStopLoss})`);
+        }
+        if (!isFinite(signal.priceStopLoss)) {
+            errors.push(`priceStopLoss must be a finite number, got ${signal.priceStopLoss} (${typeof signal.priceStopLoss})`);
+        }
     }
     // Валидация цен (только если они конечные)
-    if (isFinite(signal.priceOpen) && signal.priceOpen <= 0) {
-        errors.push(`priceOpen must be positive, got ${signal.priceOpen}`);
-    }
-    if (isFinite(signal.priceTakeProfit) && signal.priceTakeProfit <= 0) {
-        errors.push(`priceTakeProfit must be positive, got ${signal.priceTakeProfit}`);
-    }
-    if (isFinite(signal.priceStopLoss) && signal.priceStopLoss <= 0) {
-        errors.push(`priceStopLoss must be positive, got ${signal.priceStopLoss}`);
+    {
+        if (isFinite(signal.priceOpen) && signal.priceOpen <= 0) {
+            errors.push(`priceOpen must be positive, got ${signal.priceOpen}`);
+        }
+        if (isFinite(signal.priceTakeProfit) && signal.priceTakeProfit <= 0) {
+            errors.push(`priceTakeProfit must be positive, got ${signal.priceTakeProfit}`);
+        }
+        if (isFinite(signal.priceStopLoss) && signal.priceStopLoss <= 0) {
+            errors.push(`priceStopLoss must be positive, got ${signal.priceStopLoss}`);
+        }
     }
     // Валидация для long позиции
     if (signal.position === "long") {
-        if (signal.priceTakeProfit <= signal.priceOpen) {
-            errors.push(`Long: priceTakeProfit (${signal.priceTakeProfit}) must be > priceOpen (${signal.priceOpen})`);
-        }
-        if (signal.priceStopLoss >= signal.priceOpen) {
-            errors.push(`Long: priceStopLoss (${signal.priceStopLoss}) must be < priceOpen (${signal.priceOpen})`);
+        // Проверка соотношения цен для long
+        {
+            if (signal.priceTakeProfit <= signal.priceOpen) {
+                errors.push(`Long: priceTakeProfit (${signal.priceTakeProfit}) must be > priceOpen (${signal.priceOpen})`);
+            }
+            if (signal.priceStopLoss >= signal.priceOpen) {
+                errors.push(`Long: priceStopLoss (${signal.priceStopLoss}) must be < priceOpen (${signal.priceOpen})`);
+            }
         }
         // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ: проверяем что позиция не закроется сразу после открытия
-        if (!isScheduled && isFinite(currentPrice)) {
-            // LONG: currentPrice должна быть МЕЖДУ SL и TP (не пробита ни одна граница)
-            // SL < currentPrice < TP
-            if (currentPrice <= signal.priceStopLoss) {
-                errors.push(`Long immediate: currentPrice (${currentPrice}) <= priceStopLoss (${signal.priceStopLoss}). ` +
-                    `Signal would be immediately closed by stop loss. Cannot open position that is already stopped out.`);
-            }
-            if (currentPrice >= signal.priceTakeProfit) {
-                errors.push(`Long immediate: currentPrice (${currentPrice}) >= priceTakeProfit (${signal.priceTakeProfit}). ` +
-                    `Signal would be immediately closed by take profit. The profit opportunity has already passed.`);
+        {
+            if (!isScheduled && isFinite(currentPrice)) {
+                // LONG: currentPrice должна быть МЕЖДУ SL и TP (не пробита ни одна граница)
+                // SL < currentPrice < TP
+                if (currentPrice <= signal.priceStopLoss) {
+                    errors.push(`Long immediate: currentPrice (${currentPrice}) <= priceStopLoss (${signal.priceStopLoss}). ` +
+                        `Signal would be immediately closed by stop loss. Cannot open position that is already stopped out.`);
+                }
+                if (currentPrice >= signal.priceTakeProfit) {
+                    errors.push(`Long immediate: currentPrice (${currentPrice}) >= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                        `Signal would be immediately closed by take profit. The profit opportunity has already passed.`);
+                }
             }
         }
         // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ scheduled сигналов
-        if (isScheduled && isFinite(signal.priceOpen)) {
-            // LONG scheduled: priceOpen должен быть МЕЖДУ SL и TP
-            // SL < priceOpen < TP
-            if (signal.priceOpen <= signal.priceStopLoss) {
-                errors.push(`Long scheduled: priceOpen (${signal.priceOpen}) <= priceStopLoss (${signal.priceStopLoss}). ` +
-                    `Signal would be immediately cancelled on activation. Cannot activate position that is already stopped out.`);
-            }
-            if (signal.priceOpen >= signal.priceTakeProfit) {
-                errors.push(`Long scheduled: priceOpen (${signal.priceOpen}) >= priceTakeProfit (${signal.priceTakeProfit}). ` +
-                    `Signal would close immediately on activation. This is logically impossible for LONG position.`);
+        {
+            if (isScheduled && isFinite(signal.priceOpen)) {
+                // LONG scheduled: priceOpen должен быть МЕЖДУ SL и TP
+                // SL < priceOpen < TP
+                if (signal.priceOpen <= signal.priceStopLoss) {
+                    errors.push(`Long scheduled: priceOpen (${signal.priceOpen}) <= priceStopLoss (${signal.priceStopLoss}). ` +
+                        `Signal would be immediately cancelled on activation. Cannot activate position that is already stopped out.`);
+                }
+                if (signal.priceOpen >= signal.priceTakeProfit) {
+                    errors.push(`Long scheduled: priceOpen (${signal.priceOpen}) >= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                        `Signal would close immediately on activation. This is logically impossible for LONG position.`);
+                }
             }
         }
         // ЗАЩИТА ОТ МИКРО-ПРОФИТА: TakeProfit должен быть достаточно далеко, чтобы покрыть комиссии
-        if (GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
-            const tpDistancePercent = ((signal.priceTakeProfit - signal.priceOpen) / signal.priceOpen) * 100;
-            if (tpDistancePercent < GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
-                errors.push(`Long: TakeProfit too close to priceOpen (${tpDistancePercent.toFixed(3)}%). ` +
-                    `Minimum distance: ${GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT}% to cover trading fees. ` +
-                    `Current: TP=${signal.priceTakeProfit}, Open=${signal.priceOpen}`);
+        {
+            if (GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
+                const tpDistancePercent = ((signal.priceTakeProfit - signal.priceOpen) / signal.priceOpen) * 100;
+                if (tpDistancePercent < GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
+                    errors.push(`Long: TakeProfit too close to priceOpen (${tpDistancePercent.toFixed(3)}%). ` +
+                        `Minimum distance: ${GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT}% to cover trading fees. ` +
+                        `Current: TP=${signal.priceTakeProfit}, Open=${signal.priceOpen}`);
+                }
             }
         }
         // ЗАЩИТА ОТ СЛИШКОМ УЗКОГО STOPLOSS: минимальный буфер для избежания моментального закрытия
-        if (GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT) {
-            const slDistancePercent = ((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen) * 100;
-            if (slDistancePercent < GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT) {
-                errors.push(`Long: StopLoss too close to priceOpen (${slDistancePercent.toFixed(3)}%). ` +
-                    `Minimum distance: ${GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT}% to avoid instant stop out on market volatility. ` +
-                    `Current: SL=${signal.priceStopLoss}, Open=${signal.priceOpen}`);
+        {
+            if (GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT) {
+                const slDistancePercent = ((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen) * 100;
+                if (slDistancePercent < GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT) {
+                    errors.push(`Long: StopLoss too close to priceOpen (${slDistancePercent.toFixed(3)}%). ` +
+                        `Minimum distance: ${GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT}% to avoid instant stop out on market volatility. ` +
+                        `Current: SL=${signal.priceStopLoss}, Open=${signal.priceOpen}`);
+                }
             }
         }
         // ЗАЩИТА ОТ ЭКСТРЕМАЛЬНОГО STOPLOSS: ограничиваем максимальный убыток
-        if (GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
-            const slDistancePercent = ((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen) * 100;
-            if (slDistancePercent > GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
-                errors.push(`Long: StopLoss too far from priceOpen (${slDistancePercent.toFixed(3)}%). ` +
-                    `Maximum distance: ${GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT}% to protect capital. ` +
-                    `Current: SL=${signal.priceStopLoss}, Open=${signal.priceOpen}`);
+        {
+            if (GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
+                const slDistancePercent = ((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen) * 100;
+                if (slDistancePercent > GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
+                    errors.push(`Long: StopLoss too far from priceOpen (${slDistancePercent.toFixed(3)}%). ` +
+                        `Maximum distance: ${GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT}% to protect capital. ` +
+                        `Current: SL=${signal.priceStopLoss}, Open=${signal.priceOpen}`);
+                }
             }
         }
     }
     // Валидация для short позиции
     if (signal.position === "short") {
-        if (signal.priceTakeProfit >= signal.priceOpen) {
-            errors.push(`Short: priceTakeProfit (${signal.priceTakeProfit}) must be < priceOpen (${signal.priceOpen})`);
-        }
-        if (signal.priceStopLoss <= signal.priceOpen) {
-            errors.push(`Short: priceStopLoss (${signal.priceStopLoss}) must be > priceOpen (${signal.priceOpen})`);
+        // Проверка соотношения цен для short
+        {
+            if (signal.priceTakeProfit >= signal.priceOpen) {
+                errors.push(`Short: priceTakeProfit (${signal.priceTakeProfit}) must be < priceOpen (${signal.priceOpen})`);
+            }
+            if (signal.priceStopLoss <= signal.priceOpen) {
+                errors.push(`Short: priceStopLoss (${signal.priceStopLoss}) must be > priceOpen (${signal.priceOpen})`);
+            }
         }
         // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ: проверяем что позиция не закроется сразу после открытия
-        if (!isScheduled && isFinite(currentPrice)) {
-            // SHORT: currentPrice должна быть МЕЖДУ TP и SL (не пробита ни одна граница)
-            // TP < currentPrice < SL
-            if (currentPrice >= signal.priceStopLoss) {
-                errors.push(`Short immediate: currentPrice (${currentPrice}) >= priceStopLoss (${signal.priceStopLoss}). ` +
-                    `Signal would be immediately closed by stop loss. Cannot open position that is already stopped out.`);
-            }
-            if (currentPrice <= signal.priceTakeProfit) {
-                errors.push(`Short immediate: currentPrice (${currentPrice}) <= priceTakeProfit (${signal.priceTakeProfit}). ` +
-                    `Signal would be immediately closed by take profit. The profit opportunity has already passed.`);
+        {
+            if (!isScheduled && isFinite(currentPrice)) {
+                // SHORT: currentPrice должна быть МЕЖДУ TP и SL (не пробита ни одна граница)
+                // TP < currentPrice < SL
+                if (currentPrice >= signal.priceStopLoss) {
+                    errors.push(`Short immediate: currentPrice (${currentPrice}) >= priceStopLoss (${signal.priceStopLoss}). ` +
+                        `Signal would be immediately closed by stop loss. Cannot open position that is already stopped out.`);
+                }
+                if (currentPrice <= signal.priceTakeProfit) {
+                    errors.push(`Short immediate: currentPrice (${currentPrice}) <= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                        `Signal would be immediately closed by take profit. The profit opportunity has already passed.`);
+                }
             }
         }
         // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ scheduled сигналов
-        if (isScheduled && isFinite(signal.priceOpen)) {
-            // SHORT scheduled: priceOpen должен быть МЕЖДУ TP и SL
-            // TP < priceOpen < SL
-            if (signal.priceOpen >= signal.priceStopLoss) {
-                errors.push(`Short scheduled: priceOpen (${signal.priceOpen}) >= priceStopLoss (${signal.priceStopLoss}). ` +
-                    `Signal would be immediately cancelled on activation. Cannot activate position that is already stopped out.`);
-            }
-            if (signal.priceOpen <= signal.priceTakeProfit) {
-                errors.push(`Short scheduled: priceOpen (${signal.priceOpen}) <= priceTakeProfit (${signal.priceTakeProfit}). ` +
-                    `Signal would close immediately on activation. This is logically impossible for SHORT position.`);
+        {
+            if (isScheduled && isFinite(signal.priceOpen)) {
+                // SHORT scheduled: priceOpen должен быть МЕЖДУ TP и SL
+                // TP < priceOpen < SL
+                if (signal.priceOpen >= signal.priceStopLoss) {
+                    errors.push(`Short scheduled: priceOpen (${signal.priceOpen}) >= priceStopLoss (${signal.priceStopLoss}). ` +
+                        `Signal would be immediately cancelled on activation. Cannot activate position that is already stopped out.`);
+                }
+                if (signal.priceOpen <= signal.priceTakeProfit) {
+                    errors.push(`Short scheduled: priceOpen (${signal.priceOpen}) <= priceTakeProfit (${signal.priceTakeProfit}). ` +
+                        `Signal would close immediately on activation. This is logically impossible for SHORT position.`);
+                }
             }
         }
         // ЗАЩИТА ОТ МИКРО-ПРОФИТА: TakeProfit должен быть достаточно далеко, чтобы покрыть комиссии
-        if (GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
-            const tpDistancePercent = ((signal.priceOpen - signal.priceTakeProfit) / signal.priceOpen) * 100;
-            if (tpDistancePercent < GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
-                errors.push(`Short: TakeProfit too close to priceOpen (${tpDistancePercent.toFixed(3)}%). ` +
-                    `Minimum distance: ${GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT}% to cover trading fees. ` +
-                    `Current: TP=${signal.priceTakeProfit}, Open=${signal.priceOpen}`);
+        {
+            if (GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
+                const tpDistancePercent = ((signal.priceOpen - signal.priceTakeProfit) / signal.priceOpen) * 100;
+                if (tpDistancePercent < GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT) {
+                    errors.push(`Short: TakeProfit too close to priceOpen (${tpDistancePercent.toFixed(3)}%). ` +
+                        `Minimum distance: ${GLOBAL_CONFIG.CC_MIN_TAKEPROFIT_DISTANCE_PERCENT}% to cover trading fees. ` +
+                        `Current: TP=${signal.priceTakeProfit}, Open=${signal.priceOpen}`);
+                }
             }
         }
         // ЗАЩИТА ОТ СЛИШКОМ УЗКОГО STOPLOSS: минимальный буфер для избежания моментального закрытия
-        if (GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT) {
-            const slDistancePercent = ((signal.priceStopLoss - signal.priceOpen) / signal.priceOpen) * 100;
-            if (slDistancePercent < GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT) {
-                errors.push(`Short: StopLoss too close to priceOpen (${slDistancePercent.toFixed(3)}%). ` +
-                    `Minimum distance: ${GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT}% to avoid instant stop out on market volatility. ` +
-                    `Current: SL=${signal.priceStopLoss}, Open=${signal.priceOpen}`);
+        {
+            if (GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT) {
+                const slDistancePercent = ((signal.priceStopLoss - signal.priceOpen) / signal.priceOpen) * 100;
+                if (slDistancePercent < GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT) {
+                    errors.push(`Short: StopLoss too close to priceOpen (${slDistancePercent.toFixed(3)}%). ` +
+                        `Minimum distance: ${GLOBAL_CONFIG.CC_MIN_STOPLOSS_DISTANCE_PERCENT}% to avoid instant stop out on market volatility. ` +
+                        `Current: SL=${signal.priceStopLoss}, Open=${signal.priceOpen}`);
+                }
             }
         }
         // ЗАЩИТА ОТ ЭКСТРЕМАЛЬНОГО STOPLOSS: ограничиваем максимальный убыток
-        if (GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
-            const slDistancePercent = ((signal.priceStopLoss - signal.priceOpen) / signal.priceOpen) * 100;
-            if (slDistancePercent > GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
-                errors.push(`Short: StopLoss too far from priceOpen (${slDistancePercent.toFixed(3)}%). ` +
-                    `Maximum distance: ${GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT}% to protect capital. ` +
-                    `Current: SL=${signal.priceStopLoss}, Open=${signal.priceOpen}`);
+        {
+            if (GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
+                const slDistancePercent = ((signal.priceStopLoss - signal.priceOpen) / signal.priceOpen) * 100;
+                if (slDistancePercent > GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT) {
+                    errors.push(`Short: StopLoss too far from priceOpen (${slDistancePercent.toFixed(3)}%). ` +
+                        `Maximum distance: ${GLOBAL_CONFIG.CC_MAX_STOPLOSS_DISTANCE_PERCENT}% to protect capital. ` +
+                        `Current: SL=${signal.priceStopLoss}, Open=${signal.priceOpen}`);
+                }
             }
         }
     }
     // Валидация временных параметров
-    if (typeof signal.minuteEstimatedTime !== "number") {
-        errors.push(`minuteEstimatedTime must be a number type, got ${signal.minuteEstimatedTime} (${typeof signal.minuteEstimatedTime})`);
-    }
-    if (signal.minuteEstimatedTime <= 0) {
-        errors.push(`minuteEstimatedTime must be positive, got ${signal.minuteEstimatedTime}`);
-    }
-    if (!Number.isInteger(signal.minuteEstimatedTime)) {
-        errors.push(`minuteEstimatedTime must be an integer (whole number), got ${signal.minuteEstimatedTime}`);
-    }
-    if (!isFinite(signal.minuteEstimatedTime)) {
-        errors.push(`minuteEstimatedTime must be a finite number, got ${signal.minuteEstimatedTime}`);
+    {
+        if (typeof signal.minuteEstimatedTime !== "number") {
+            errors.push(`minuteEstimatedTime must be a number type, got ${signal.minuteEstimatedTime} (${typeof signal.minuteEstimatedTime})`);
+        }
+        if (signal.minuteEstimatedTime <= 0) {
+            errors.push(`minuteEstimatedTime must be positive, got ${signal.minuteEstimatedTime}`);
+        }
+        if (!Number.isInteger(signal.minuteEstimatedTime)) {
+            errors.push(`minuteEstimatedTime must be an integer (whole number), got ${signal.minuteEstimatedTime}`);
+        }
+        if (!isFinite(signal.minuteEstimatedTime)) {
+            errors.push(`minuteEstimatedTime must be a finite number, got ${signal.minuteEstimatedTime}`);
+        }
     }
     // ЗАЩИТА ОТ ВЕЧНЫХ СИГНАЛОВ: ограничиваем максимальное время жизни сигнала
-    if (GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES && GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES) {
-        if (signal.minuteEstimatedTime > GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES) {
-            const days = (signal.minuteEstimatedTime / 60 / 24).toFixed(1);
-            const maxDays = (GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES / 60 / 24).toFixed(0);
-            errors.push(`minuteEstimatedTime too large (${signal.minuteEstimatedTime} minutes = ${days} days). ` +
-                `Maximum: ${GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES} minutes (${maxDays} days) to prevent strategy deadlock. ` +
-                `Eternal signals block risk limits and prevent new trades.`);
+    {
+        if (GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES && GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES) {
+            if (signal.minuteEstimatedTime > GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES) {
+                const days = (signal.minuteEstimatedTime / 60 / 24).toFixed(1);
+                const maxDays = (GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES / 60 / 24).toFixed(0);
+                errors.push(`minuteEstimatedTime too large (${signal.minuteEstimatedTime} minutes = ${days} days). ` +
+                    `Maximum: ${GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES} minutes (${maxDays} days) to prevent strategy deadlock. ` +
+                    `Eternal signals block risk limits and prevent new trades.`);
+            }
         }
     }
-    if (typeof signal.scheduledAt !== "number") {
-        errors.push(`scheduledAt must be a number type, got ${signal.scheduledAt} (${typeof signal.scheduledAt})`);
-    }
-    if (signal.scheduledAt <= 0) {
-        errors.push(`scheduledAt must be positive, got ${signal.scheduledAt}`);
-    }
-    if (typeof signal.pendingAt !== "number") {
-        errors.push(`pendingAt must be a number type, got ${signal.pendingAt} (${typeof signal.pendingAt})`);
-    }
-    if (signal.pendingAt <= 0) {
-        errors.push(`pendingAt must be positive, got ${signal.pendingAt}`);
+    // Валидация временных меток
+    {
+        if (typeof signal.scheduledAt !== "number") {
+            errors.push(`scheduledAt must be a number type, got ${signal.scheduledAt} (${typeof signal.scheduledAt})`);
+        }
+        if (signal.scheduledAt <= 0) {
+            errors.push(`scheduledAt must be positive, got ${signal.scheduledAt}`);
+        }
+        if (typeof signal.pendingAt !== "number") {
+            errors.push(`pendingAt must be a number type, got ${signal.pendingAt} (${typeof signal.pendingAt})`);
+        }
+        if (signal.pendingAt <= 0) {
+            errors.push(`pendingAt must be positive, got ${signal.pendingAt}`);
+        }
     }
     // Кидаем ошибку если есть проблемы
     if (errors.length > 0) {
@@ -2384,6 +2501,97 @@ const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice) => {
         slClosed: slClosed + percentToClose,
     });
 };
+const TRAILING_STOP_FN = (self, signal, percentShift) => {
+    // Calculate distance between entry and original stop-loss AS PERCENTAGE of entry price
+    const slDistancePercent = Math.abs((signal.priceOpen - signal.priceStopLoss) / signal.priceOpen * 100);
+    // Calculate new stop-loss distance percentage by adding shift
+    // 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 = slDistancePercent + 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, originalSL=90 (10%), shift=-15% → newDistance=-5% → 100 * 1.05 = 105 (profit zone)
+        // Example: entry=100, originalSL=90 (10%), shift=-5% → newDistance=5% → 100 * 0.95 = 95 (tighter)
+        // Example: entry=100, originalSL=90 (10%), shift=+5% → newDistance=15% → 100 * 0.85 = 85 (looser)
+        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, originalSL=110 (10%), shift=-15% → newDistance=-5% → 100 * 0.95 = 95 (profit zone)
+        // Example: entry=100, originalSL=110 (10%), shift=-5% → newDistance=5% → 100 * 1.05 = 105 (tighter)
+        // Example: entry=100, originalSL=110 (10%), shift=+5% → newDistance=15% → 100 * 1.15 = 115 (looser)
+        newStopLoss = signal.priceOpen * (1 + newSlDistancePercent / 100);
+    }
+    // Get current effective stop-loss (trailing or original)
+    const currentStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
+    // Determine if this is the first trailing stop call (direction not set yet)
+    const isFirstCall = signal._trailingPriceStopLoss === undefined;
+    if (isFirstCall) {
+        // First call: set the direction and update SL unconditionally
+        signal._trailingPriceStopLoss = newStopLoss;
+        self.params.logger.info("TRAILING_STOP_FN executed (first call - direction set)", {
+            signalId: signal.id,
+            position: signal.position,
+            priceOpen: signal.priceOpen,
+            originalStopLoss: signal.priceStopLoss,
+            originalDistancePercent: slDistancePercent,
+            previousStopLoss: currentStopLoss,
+            newStopLoss,
+            newDistancePercent: newSlDistancePercent,
+            percentShift,
+            inProfitZone: signal.position === "long" ? newStopLoss > signal.priceOpen : newStopLoss < signal.priceOpen,
+            direction: newStopLoss > currentStopLoss ? "up" : "down",
+        });
+    }
+    else {
+        // Subsequent calls: only update if new SL continues in the same direction
+        const movingUp = newStopLoss > currentStopLoss;
+        const movingDown = newStopLoss < currentStopLoss;
+        // Determine initial direction based on first trailing SL vs original SL
+        const initialDirection = signal._trailingPriceStopLoss > signal.priceStopLoss ? "up" : "down";
+        let shouldUpdate = false;
+        if (initialDirection === "up" && movingUp) {
+            // Direction is UP, and new SL continues moving up
+            shouldUpdate = true;
+        }
+        else if (initialDirection === "down" && movingDown) {
+            // Direction is DOWN, and new SL continues moving down
+            shouldUpdate = true;
+        }
+        if (!shouldUpdate) {
+            self.params.logger.debug("TRAILING_STOP_FN: new SL not in same direction, skipping", {
+                signalId: signal.id,
+                position: signal.position,
+                currentStopLoss,
+                newStopLoss,
+                percentShift,
+                initialDirection,
+                attemptedDirection: movingUp ? "up" : movingDown ? "down" : "same",
+            });
+            return;
+        }
+        // Update trailing stop-loss
+        signal._trailingPriceStopLoss = newStopLoss;
+        self.params.logger.info("TRAILING_STOP_FN executed", {
+            signalId: signal.id,
+            position: signal.position,
+            priceOpen: signal.priceOpen,
+            originalStopLoss: signal.priceStopLoss,
+            originalDistancePercent: slDistancePercent,
+            previousStopLoss: currentStopLoss,
+            newStopLoss,
+            newDistancePercent: newSlDistancePercent,
+            percentShift,
+            inProfitZone: signal.position === "long" ? newStopLoss > signal.priceOpen : newStopLoss < signal.priceOpen,
+            direction: initialDirection,
+        });
+    }
+};
 const CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN = async (self, scheduled, currentPrice) => {
     const currentTime = self.params.execution.context.when.getTime();
     const signalTime = scheduled.scheduledAt; // Таймаут для scheduled signal считается от scheduledAt
@@ -2402,7 +2610,7 @@ const CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN = async (self, scheduled, currentPrice)
     await CALL_CANCEL_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, currentPrice, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "cancelled",
-        signal: scheduled,
+        signal: TO_PUBLIC_SIGNAL(scheduled),
         currentPrice: currentPrice,
         closeTimestamp: currentTime,
         strategyName: self.params.method.context.strategyName,
@@ -2457,7 +2665,7 @@ const CANCEL_SCHEDULED_SIGNAL_BY_STOPLOSS_FN = async (self, scheduled, currentPr
     await CALL_CANCEL_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, currentPrice, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "cancelled",
-        signal: scheduled,
+        signal: TO_PUBLIC_SIGNAL(scheduled),
         currentPrice: currentPrice,
         closeTimestamp: currentTime,
         strategyName: self.params.method.context.strategyName,
@@ -2514,7 +2722,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
     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",
-        signal: self._pendingSignal,
+        signal: TO_PUBLIC_SIGNAL(self._pendingSignal),
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         frameName: self.params.method.context.frameName,
@@ -2527,11 +2735,12 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
 };
 const CALL_PING_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, scheduled, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
+        const publicSignal = TO_PUBLIC_SIGNAL(scheduled);
         // Call system onPing callback first (emits to pingSubject)
-        await self.params.onPing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, scheduled, self.params.execution.context.backtest, timestamp);
+        await self.params.onPing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, publicSignal, self.params.execution.context.backtest, timestamp);
         // Call user onPing callback only if signal is still active (not cancelled, not activated)
         if (self.params.callbacks?.onPing) {
-            await self.params.callbacks.onPing(self.params.execution.context.symbol, scheduled, new Date(timestamp), self.params.execution.context.backtest);
+            await self.params.callbacks.onPing(self.params.execution.context.symbol, publicSignal, new Date(timestamp), self.params.execution.context.backtest);
         }
     }, {
         when: new Date(timestamp),
@@ -2553,7 +2762,8 @@ const CALL_PING_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, schedu
 const CALL_ACTIVE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
         if (self.params.callbacks?.onActive) {
-            self.params.callbacks.onActive(self.params.execution.context.symbol, signal, currentPrice, self.params.execution.context.backtest);
+            const publicSignal = TO_PUBLIC_SIGNAL(signal);
+            await self.params.callbacks.onActive(self.params.execution.context.symbol, publicSignal, currentPrice, self.params.execution.context.backtest);
         }
     }, {
         when: new Date(timestamp),
@@ -2575,7 +2785,8 @@ const CALL_ACTIVE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, sign
 const CALL_SCHEDULE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
         if (self.params.callbacks?.onSchedule) {
-            self.params.callbacks.onSchedule(self.params.execution.context.symbol, signal, currentPrice, self.params.execution.context.backtest);
+            const publicSignal = TO_PUBLIC_SIGNAL(signal);
+            await self.params.callbacks.onSchedule(self.params.execution.context.symbol, publicSignal, currentPrice, self.params.execution.context.backtest);
         }
     }, {
         when: new Date(timestamp),
@@ -2597,7 +2808,8 @@ const CALL_SCHEDULE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, si
 const CALL_CANCEL_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
         if (self.params.callbacks?.onCancel) {
-            self.params.callbacks.onCancel(self.params.execution.context.symbol, signal, currentPrice, self.params.execution.context.backtest);
+            const publicSignal = TO_PUBLIC_SIGNAL(signal);
+            await self.params.callbacks.onCancel(self.params.execution.context.symbol, publicSignal, currentPrice, self.params.execution.context.backtest);
         }
     }, {
         when: new Date(timestamp),
@@ -2619,7 +2831,8 @@ const CALL_CANCEL_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, sign
 const CALL_OPEN_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, priceOpen, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
         if (self.params.callbacks?.onOpen) {
-            self.params.callbacks.onOpen(self.params.execution.context.symbol, signal, priceOpen, self.params.execution.context.backtest);
+            const publicSignal = TO_PUBLIC_SIGNAL(signal);
+            await self.params.callbacks.onOpen(self.params.execution.context.symbol, publicSignal, priceOpen, self.params.execution.context.backtest);
         }
     }, {
         when: new Date(timestamp),
@@ -2641,7 +2854,8 @@ const CALL_OPEN_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal
 const CALL_CLOSE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
         if (self.params.callbacks?.onClose) {
-            self.params.callbacks.onClose(self.params.execution.context.symbol, signal, currentPrice, self.params.execution.context.backtest);
+            const publicSignal = TO_PUBLIC_SIGNAL(signal);
+            await self.params.callbacks.onClose(self.params.execution.context.symbol, publicSignal, currentPrice, self.params.execution.context.backtest);
         }
     }, {
         when: new Date(timestamp),
@@ -2663,7 +2877,7 @@ const CALL_CLOSE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signa
 const CALL_TICK_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, result, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
         if (self.params.callbacks?.onTick) {
-            self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
+            await self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
         }
     }, {
         when: new Date(timestamp),
@@ -2685,7 +2899,7 @@ const CALL_TICK_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, result
 const CALL_IDLE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, currentPrice, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
         if (self.params.callbacks?.onIdle) {
-            self.params.callbacks.onIdle(self.params.execution.context.symbol, currentPrice, self.params.execution.context.backtest);
+            await self.params.callbacks.onIdle(self.params.execution.context.symbol, currentPrice, self.params.execution.context.backtest);
         }
     }, {
         when: new Date(timestamp),
@@ -2756,7 +2970,8 @@ const CALL_RISK_REMOVE_SIGNAL_FN = functoolsKit.trycatch(async (self, symbol, ti
 });
 const CALL_PARTIAL_CLEAR_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
-        await self.params.partial.clear(symbol, signal, currentPrice, backtest);
+        const publicSignal = TO_PUBLIC_SIGNAL(signal);
+        await self.params.partial.clear(symbol, publicSignal, currentPrice, backtest);
     }, {
         when: new Date(timestamp),
         symbol: symbol,
@@ -2805,9 +3020,10 @@ const CALL_RISK_CHECK_SIGNAL_FN = functoolsKit.trycatch(async (self, symbol, pen
 });
 const CALL_PARTIAL_PROFIT_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, percentTp, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
-        await self.params.partial.profit(symbol, signal, currentPrice, percentTp, backtest, new Date(timestamp));
+        const publicSignal = TO_PUBLIC_SIGNAL(signal);
+        await self.params.partial.profit(symbol, publicSignal, currentPrice, percentTp, backtest, new Date(timestamp));
         if (self.params.callbacks?.onPartialProfit) {
-            self.params.callbacks.onPartialProfit(symbol, signal, currentPrice, percentTp, backtest);
+            await self.params.callbacks.onPartialProfit(symbol, publicSignal, currentPrice, percentTp, backtest);
         }
     }, {
         when: new Date(timestamp),
@@ -2828,9 +3044,10 @@ const CALL_PARTIAL_PROFIT_CALLBACKS_FN = functoolsKit.trycatch(async (self, symb
 });
 const CALL_PARTIAL_LOSS_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, percentSl, timestamp, backtest) => {
     await ExecutionContextService.runInContext(async () => {
-        await self.params.partial.loss(symbol, signal, currentPrice, percentSl, backtest, new Date(timestamp));
+        const publicSignal = TO_PUBLIC_SIGNAL(signal);
+        await self.params.partial.loss(symbol, publicSignal, currentPrice, percentSl, backtest, new Date(timestamp));
         if (self.params.callbacks?.onPartialLoss) {
-            self.params.callbacks.onPartialLoss(symbol, signal, currentPrice, percentSl, backtest);
+            await self.params.callbacks.onPartialLoss(symbol, publicSignal, currentPrice, percentSl, backtest);
         }
     }, {
         when: new Date(timestamp),
@@ -2854,7 +3071,7 @@ const RETURN_SCHEDULED_SIGNAL_ACTIVE_FN = async (self, scheduled, currentPrice)
     await CALL_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "active",
-        signal: scheduled,
+        signal: TO_PUBLIC_SIGNAL(scheduled),
         currentPrice: currentPrice,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
@@ -2880,7 +3097,7 @@ const OPEN_NEW_SCHEDULED_SIGNAL_FN = async (self, signal) => {
     await CALL_SCHEDULE_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "scheduled",
-        signal: signal,
+        signal: TO_PUBLIC_SIGNAL(signal),
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         frameName: self.params.method.context.frameName,
@@ -2900,7 +3117,7 @@ const OPEN_NEW_PENDING_SIGNAL_FN = async (self, signal) => {
     await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, signal.priceOpen, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "opened",
-        signal: signal,
+        signal: TO_PUBLIC_SIGNAL(signal),
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         frameName: self.params.method.context.frameName,
@@ -2929,13 +3146,14 @@ const CHECK_PENDING_SIGNAL_COMPLETION_FN = async (self, signal, averagePrice) =>
         return await CLOSE_PENDING_SIGNAL_FN(self, signal, signal.priceTakeProfit, // КРИТИЧНО: используем точную цену TP
         "take_profit");
     }
-    // Check stop loss
-    if (signal.position === "long" && averagePrice <= signal.priceStopLoss) {
-        return await CLOSE_PENDING_SIGNAL_FN(self, signal, signal.priceStopLoss, // КРИТИЧНО: используем точную цену SL
+    // Check stop loss (use trailing SL if set, otherwise original SL)
+    const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
+    if (signal.position === "long" && averagePrice <= effectiveStopLoss) {
+        return await CLOSE_PENDING_SIGNAL_FN(self, signal, effectiveStopLoss, // КРИТИЧНО: используем точную цену SL (trailing or original)
         "stop_loss");
     }
-    if (signal.position === "short" && averagePrice >= signal.priceStopLoss) {
-        return await CLOSE_PENDING_SIGNAL_FN(self, signal, signal.priceStopLoss, // КРИТИЧНО: используем точную цену SL
+    if (signal.position === "short" && averagePrice >= effectiveStopLoss) {
+        return await CLOSE_PENDING_SIGNAL_FN(self, signal, effectiveStopLoss, // КРИТИЧНО: используем точную цену SL (trailing or original)
         "stop_loss");
     }
     return null;
@@ -2957,7 +3175,7 @@ const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason)
     await self.setPendingSignal(null);
     const result = {
         action: "closed",
-        signal: signal,
+        signal: TO_PUBLIC_SIGNAL(signal),
         currentPrice: currentPrice,
         closeReason: closeReason,
         closeTimestamp: currentTime,
@@ -2988,8 +3206,9 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
                 await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentTp, currentTime, self.params.execution.context.backtest);
             }
             else if (currentDistance < 0) {
-                // Moving towards SL
-                const slDistance = signal.priceOpen - signal.priceStopLoss;
+                // Moving towards SL (use trailing SL if set)
+                const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
+                const slDistance = signal.priceOpen - effectiveStopLoss;
                 const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                 percentSl = Math.min(progressPercent, 100);
                 await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentSl, currentTime, self.params.execution.context.backtest);
@@ -3006,8 +3225,9 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
                 await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentTp, currentTime, self.params.execution.context.backtest);
             }
             if (currentDistance < 0) {
-                // Moving towards SL
-                const slDistance = signal.priceStopLoss - signal.priceOpen;
+                // Moving towards SL (use trailing SL if set)
+                const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
+                const slDistance = effectiveStopLoss - signal.priceOpen;
                 const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                 percentSl = Math.min(progressPercent, 100);
                 await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentSl, currentTime, self.params.execution.context.backtest);
@@ -3016,7 +3236,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
     }
     const result = {
         action: "active",
-        signal: signal,
+        signal: TO_PUBLIC_SIGNAL(signal),
         currentPrice: currentPrice,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
@@ -3058,7 +3278,7 @@ const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePr
     await CALL_CANCEL_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, averagePrice, closeTimestamp, self.params.execution.context.backtest);
     const result = {
         action: "cancelled",
-        signal: scheduled,
+        signal: TO_PUBLIC_SIGNAL(scheduled),
         currentPrice: averagePrice,
         closeTimestamp: closeTimestamp,
         strategyName: self.params.method.context.strategyName,
@@ -3135,7 +3355,7 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
     await self.setPendingSignal(null);
     const result = {
         action: "closed",
-        signal: signal,
+        signal: TO_PUBLIC_SIGNAL(signal),
         currentPrice: averagePrice,
         closeReason: closeReason,
         closeTimestamp: closeTimestamp,
@@ -3259,13 +3479,15 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         }
         // Check TP/SL only if not expired
         // КРИТИЧНО: используем candle.high/low для точной проверки достижения TP/SL
+        // КРИТИЧНО: используем trailing SL если установлен
+        const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
         if (!shouldClose && signal.position === "long") {
             // Для LONG: TP срабатывает если high >= TP, SL если low <= SL
             if (currentCandle.high >= signal.priceTakeProfit) {
                 shouldClose = true;
                 closeReason = "take_profit";
             }
-            else if (currentCandle.low <= signal.priceStopLoss) {
+            else if (currentCandle.low <= effectiveStopLoss) {
                 shouldClose = true;
                 closeReason = "stop_loss";
             }
@@ -3276,7 +3498,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                 shouldClose = true;
                 closeReason = "take_profit";
             }
-            else if (currentCandle.high >= signal.priceStopLoss) {
+            else if (currentCandle.high >= effectiveStopLoss) {
                 shouldClose = true;
                 closeReason = "stop_loss";
             }
@@ -3288,7 +3510,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                 closePrice = signal.priceTakeProfit;
             }
             else if (closeReason === "stop_loss") {
-                closePrice = signal.priceStopLoss;
+                closePrice = effectiveStopLoss; // Используем trailing SL если установлен
             }
             return await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(self, signal, closePrice, closeReason, currentCandleTimestamp);
         }
@@ -3305,8 +3527,9 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
                 else if (currentDistance < 0) {
-                    // Moving towards SL
-                    const slDistance = signal.priceOpen - signal.priceStopLoss;
+                    // Moving towards SL (use trailing SL if set)
+                    const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
+                    const slDistance = signal.priceOpen - effectiveStopLoss;
                     const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                     await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
@@ -3321,8 +3544,9 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
                 if (currentDistance < 0) {
-                    // Moving towards SL
-                    const slDistance = signal.priceStopLoss - signal.priceOpen;
+                    // Moving towards SL (use trailing SL if set)
+                    const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
+                    const slDistance = effectiveStopLoss - signal.priceOpen;
                     const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                     await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
@@ -3394,7 +3618,8 @@ class ClientStrategy {
         // КРИТИЧНО: Всегда вызываем коллбек onWrite для тестирования persist storage
         // даже в backtest режиме, чтобы тесты могли перехватывать вызовы через mock adapter
         if (this.params.callbacks?.onWrite) {
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, this._pendingSignal, this.params.execution.context.backtest);
+            const publicSignal = this._pendingSignal ? TO_PUBLIC_SIGNAL(this._pendingSignal) : null;
+            this.params.callbacks.onWrite(this.params.execution.context.symbol, publicSignal, this.params.execution.context.backtest);
         }
         if (this.params.execution.context.backtest) {
             return;
@@ -3429,7 +3654,7 @@ class ClientStrategy {
         this.params.logger.debug("ClientStrategy getPendingSignal", {
             symbol,
         });
-        return this._pendingSignal;
+        return this._pendingSignal ? TO_PUBLIC_SIGNAL(this._pendingSignal) : null;
     }
     /**
      * Retrieves the current scheduled signal.
@@ -3440,7 +3665,7 @@ class ClientStrategy {
         this.params.logger.debug("ClientStrategy getScheduledSignal", {
             symbol,
         });
-        return this._scheduledSignal;
+        return this._scheduledSignal ? TO_PUBLIC_SIGNAL(this._scheduledSignal) : null;
     }
     /**
      * Returns the stopped state of the strategy.
@@ -3513,7 +3738,7 @@ class ClientStrategy {
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, currentTime, this.params.execution.context.backtest);
             const result = {
                 action: "cancelled",
-                signal: cancelledSignal,
+                signal: TO_PUBLIC_SIGNAL(cancelledSignal),
                 currentPrice,
                 closeTimestamp: currentTime,
                 strategyName: this.params.method.context.strategyName,
@@ -3626,7 +3851,7 @@ class ClientStrategy {
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             const cancelledResult = {
                 action: "cancelled",
-                signal: cancelledSignal,
+                signal: TO_PUBLIC_SIGNAL(cancelledSignal),
                 currentPrice,
                 closeTimestamp: closeTimestamp,
                 strategyName: this.params.method.context.strategyName,
@@ -3688,7 +3913,7 @@ class ClientStrategy {
                     // but this is correct behavior if someone calls backtest() with partial data
                     const result = {
                         action: "active",
-                        signal: scheduled,
+                        signal: TO_PUBLIC_SIGNAL(scheduled),
                         currentPrice: lastPrice,
                         percentSl: 0,
                         percentTp: 0,
@@ -3893,7 +4118,7 @@ class ClientStrategy {
         });
         // Call onWrite callback for testing persist storage
         if (this.params.callbacks?.onWrite) {
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, this._pendingSignal, backtest);
+            this.params.callbacks.onWrite(this.params.execution.context.symbol, TO_PUBLIC_SIGNAL(this._pendingSignal), backtest);
         }
         if (!backtest) {
             await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName);
@@ -3985,7 +4210,90 @@ class ClientStrategy {
         });
         // Call onWrite callback for testing persist storage
         if (this.params.callbacks?.onWrite) {
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, this._pendingSignal, backtest);
+            this.params.callbacks.onWrite(this.params.execution.context.symbol, TO_PUBLIC_SIGNAL(this._pendingSignal), backtest);
+        }
+        if (!backtest) {
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName);
+        }
+    }
+    /**
+     * Adjusts trailing stop-loss by shifting distance between entry and original SL.
+     *
+     * Calculates new SL based on percentage shift of the 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 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:
+     * - 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
+     *
+     * Validation:
+     * - Throws if no pending signal exists
+     * - Throws if percentShift is not a finite number
+     * - Throws if percentShift < -100 or > 100
+     * - Throws if percentShift === 0
+     * - Skips if new SL would cross entry price
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentShift - Percentage shift of SL distance [-100, 100], excluding 0
+     * @param backtest - Whether running in backtest mode (controls persistence)
+     * @returns Promise that resolves when trailing SL is updated and persisted
+     *
+     * @example
+     * ```typescript
+     * // LONG position: entry=100, originalSL=90, distance=10
+     *
+     * // Move SL 50% closer to entry (tighten)
+     * await strategy.trailingStop("BTCUSDT", -50, false);
+     * // newSL = 100 - 10*(1-0.5) = 95
+     *
+     * // Move SL 30% away from entry (loosen, allow more drawdown)
+     * await strategy.trailingStop("BTCUSDT", 30, false);
+     * // newSL = 100 - 10*(1+0.3) = 87 (SKIPPED: worse than current 95)
+     * ```
+     */
+    async trailingStop(symbol, percentShift, backtest) {
+        this.params.logger.debug("ClientStrategy trailingStop", {
+            symbol,
+            percentShift,
+            hasPendingSignal: this._pendingSignal !== null,
+        });
+        // Validation: must have pending signal
+        if (!this._pendingSignal) {
+            throw new Error(`ClientStrategy trailingStop: No pending signal exists for symbol=${symbol}`);
+        }
+        // Validation: percentShift must be valid
+        if (typeof percentShift !== "number" || !isFinite(percentShift)) {
+            throw new Error(`ClientStrategy trailingStop: percentShift must be a finite number, got ${percentShift} (${typeof percentShift})`);
+        }
+        if (percentShift < -100 || percentShift > 100) {
+            throw new Error(`ClientStrategy trailingStop: percentShift must be in range [-100, 100], got ${percentShift}`);
+        }
+        if (percentShift === 0) {
+            throw new Error(`ClientStrategy trailingStop: percentShift cannot be 0`);
+        }
+        // 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)", {
+            pendingSignal: this._pendingSignal,
+        });
+        // Call onWrite callback for testing persist storage
+        if (this.params.callbacks?.onWrite) {
+            const publicSignal = TO_PUBLIC_SIGNAL(this._pendingSignal);
+            this.params.callbacks.onWrite(this.params.execution.context.symbol, publicSignal, backtest);
         }
         if (!backtest) {
             await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName);
@@ -4659,40 +4967,76 @@ class StrategyConnectionService {
         /**
          * Executes partial close at loss level (moving toward SL).
          *
-         * Closes a percentage of the pending position at the current price, recording it as a "loss" type partial.
-         * The partial close is tracked in `_partial` array for weighted PNL calculation when position fully closes.
+         * Closes a percentage of the pending position at the current price, recording it as a "loss" type partial.
+         * The partial close is tracked in `_partial` array for weighted PNL calculation when position fully closes.
+         *
+         * Delegates to ClientStrategy.partialLoss() with current execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @param percentToClose - Percentage of position to close (0-100, absolute value)
+         * @param currentPrice - Current market price for this partial close
+         * @returns Promise that resolves when state is updated and persisted
+         *
+         * @example
+         * ```typescript
+         * // Close 40% of position at loss
+         * await strategyConnectionService.partialLoss(
+         *   false,
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" },
+         *   40,
+         *   38000
+         * );
+         * ```
+         */
+        this.partialLoss = async (backtest, symbol, percentToClose, currentPrice, context) => {
+            this.loggerService.log("strategyConnectionService partialLoss", {
+                symbol,
+                context,
+                percentToClose,
+                currentPrice,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await strategy.partialLoss(symbol, percentToClose, currentPrice, backtest);
+        };
+        /**
+         * 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.
          *
-         * Delegates to ClientStrategy.partialLoss() with current execution context.
+         * Delegates to ClientStrategy.trailingStop() with current execution context.
          *
          * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
          * @param context - Execution context with strategyName, exchangeName, frameName
-         * @param percentToClose - Percentage of position to close (0-100, absolute value)
-         * @param currentPrice - Current market price for this partial close
-         * @returns Promise that resolves when state is updated and persisted
+         * @returns Promise that resolves when trailing SL is updated
          *
          * @example
          * ```typescript
-         * // Close 40% of position at loss
-         * await strategyConnectionService.partialLoss(
+         * // LONG: entry=100, originalSL=90, distance=10
+         * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
+         * await strategyConnectionService.trailingStop(
          *   false,
          *   "BTCUSDT",
-         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" },
-         *   40,
-         *   38000
+         *   -50,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
          * );
          * ```
          */
-        this.partialLoss = async (backtest, symbol, percentToClose, currentPrice, context) => {
-            this.loggerService.log("strategyConnectionService partialLoss", {
+        this.trailingStop = async (backtest, symbol, percentShift, context) => {
+            this.loggerService.log("strategyConnectionService trailingStop", {
                 symbol,
                 context,
-                percentToClose,
-                currentPrice,
+                percentShift,
                 backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.partialLoss(symbol, percentToClose, currentPrice, backtest);
+            await strategy.trailingStop(symbol, percentShift, backtest);
         };
     }
 }
@@ -4716,6 +5060,32 @@ const INTERVAL_MINUTES$2 = {
     "1d": 1440,
     "3d": 4320,
 };
+/**
+ * Wrapper to call onTimeframe callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param self - ClientFrame instance reference
+ * @param timeframe - Array of generated timestamp dates
+ * @param startDate - Start date of the backtest period
+ * @param endDate - Effective end date of the backtest period
+ * @param interval - Frame interval used for generation
+ */
+const CALL_TIMEFRAME_CALLBACKS_FN = functoolsKit.trycatch(async (self, timeframe, startDate, endDate, interval) => {
+    if (self.params.callbacks?.onTimeframe) {
+        await self.params.callbacks.onTimeframe(timeframe, startDate, endDate, interval);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientFrame CALL_TIMEFRAME_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Generates timeframe array from startDate to endDate with specified interval.
  * Uses prototype function pattern for memory efficiency.
@@ -4745,9 +5115,7 @@ const GET_TIMEFRAME_FN = async (symbol, self) => {
         timeframes.push(new Date(currentDate));
         currentDate = new Date(currentDate.getTime() + intervalMinutes * 60 * 1000);
     }
-    if (self.params.callbacks?.onTimeframe) {
-        self.params.callbacks.onTimeframe(timeframes, startDate, effectiveEndDate, interval);
-    }
+    await CALL_TIMEFRAME_CALLBACKS_FN(self, timeframes, startDate, effectiveEndDate, interval);
     return timeframes;
 };
 /**
@@ -4906,6 +5274,30 @@ const calculateATRBased = (params, schema) => {
     const stopDistance = atr * atrMultiplier;
     return riskAmount / stopDistance;
 };
+/**
+ * Wrapper to call onCalculate callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param self - ClientSizing instance reference
+ * @param quantity - Calculated position size
+ * @param params - Parameters used for size calculation
+ */
+const CALL_CALCULATE_CALLBACKS_FN = functoolsKit.trycatch(async (self, quantity, params) => {
+    if (self.params.callbacks?.onCalculate) {
+        await self.params.callbacks.onCalculate(quantity, params);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientSizing CALL_CALCULATE_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Main calculation function routing to specific sizing method.
  * Applies min/max constraints after calculation.
@@ -4959,9 +5351,7 @@ const CALCULATE_FN = async (params, self) => {
         quantity = Math.min(quantity, schema.maxPositionSize);
     }
     // Trigger callback if defined
-    if (schema.callbacks?.onCalculate) {
-        schema.callbacks.onCalculate(quantity, params);
-    }
+    await CALL_CALCULATE_CALLBACKS_FN(self, quantity, params);
     return quantity;
 };
 /**
@@ -5077,6 +5467,50 @@ const get = (object, path) => {
 
 /** Symbol indicating that positions need to be fetched from persistence */
 const POSITION_NEED_FETCH = Symbol("risk-need-fetch");
+/**
+ * Converts signal to risk validation format.
+ *
+ * This function is used BEFORE position opens during risk checks.
+ * It ensures all required fields are present for risk validation:
+ *
+ * - Falls back to currentPrice if priceOpen is not set (for ISignalDto/scheduled signals)
+ * - Replaces priceStopLoss with trailing SL if active (for positions with trailing stops)
+ * - Preserves original stop-loss in originalPriceStopLoss for reference
+ *
+ * Use cases:
+ * - Risk validation before opening a position (checkSignal)
+ * - Pre-flight validation of scheduled signals
+ * - Calculating position size based on stop-loss distance
+ *
+ * @param signal - Signal DTO or row (may not have priceOpen for scheduled signals)
+ * @param currentPrice - Current market price, used as fallback for priceOpen if not set
+ * @returns Signal in IRiskSignalRow format with guaranteed priceOpen and effective stop-loss
+ *
+ * @example
+ * ```typescript
+ * // For scheduled signal without priceOpen
+ * const riskSignal = TO_RISK_SIGNAL(scheduledSignal, 45000);
+ * // riskSignal.priceOpen = 45000 (fallback to currentPrice)
+ *
+ * // For signal with trailing SL
+ * const riskSignal = TO_RISK_SIGNAL(activeSignal, 46000);
+ * // riskSignal.priceStopLoss = activeSignal._trailingPriceStopLoss
+ * ```
+ */
+const TO_RISK_SIGNAL = (signal, currentPrice) => {
+    if ("_trailingPriceStopLoss" in signal) {
+        return {
+            ...signal,
+            priceStopLoss: signal._trailingPriceStopLoss,
+            originalPriceStopLoss: signal.priceStopLoss,
+        };
+    }
+    return {
+        ...signal,
+        priceOpen: signal.priceOpen ?? currentPrice,
+        originalPriceStopLoss: signal.priceStopLoss,
+    };
+};
 /** Key generator for active position map */
 const CREATE_NAME_FN = (strategyName, exchangeName, symbol) => `${strategyName}_${exchangeName}_${symbol}`;
 /** Wrapper to execute risk validation function with error handling */
@@ -5096,6 +5530,40 @@ const DO_VALIDATION_FN = async (validation, params) => {
         return payload.message;
     }
 };
+/** Wrapper to call onRejected callback with error handling */
+const CALL_REJECTED_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, params) => {
+    if (self.params.callbacks?.onRejected) {
+        await self.params.callbacks.onRejected(symbol, params);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientRisk CALL_REJECTED_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/** Wrapper to call onAllowed callback with error handling */
+const CALL_ALLOWED_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, params) => {
+    if (self.params.callbacks?.onAllowed) {
+        await self.params.callbacks.onAllowed(symbol, params);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientRisk CALL_ALLOWED_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Initializes active positions by reading from persistence.
  * Uses singleshot pattern to ensure it only runs once.
@@ -5166,6 +5634,7 @@ class ClientRisk {
             const riskMap = this._activePositions;
             const payload = {
                 ...params,
+                pendingSignal: TO_RISK_SIGNAL(params.pendingSignal, params.currentPrice),
                 activePositionCount: riskMap.size,
                 activePositions: Array.from(riskMap.values()),
             };
@@ -5200,15 +5669,11 @@ class ClientRisk {
                 // Call params.onRejected for riskSubject emission
                 await this.params.onRejected(params.symbol, params, riskMap.size, rejectionResult, params.timestamp, this.params.backtest);
                 // Call schema callbacks.onRejected if defined
-                if (this.params.callbacks?.onRejected) {
-                    this.params.callbacks.onRejected(params.symbol, params);
-                }
+                await CALL_REJECTED_CALLBACKS_FN(this, params.symbol, params);
                 return false;
             }
             // All checks passed
-            if (this.params.callbacks?.onAllowed) {
-                this.params.callbacks.onAllowed(params.symbol, params);
-            }
+            await CALL_ALLOWED_CALLBACKS_FN(this, params.symbol, params);
             return true;
         };
     }
@@ -5896,6 +6361,42 @@ class StrategyCoreService {
             await this.validate(symbol, context);
             return await this.strategyConnectionService.partialLoss(backtest, symbol, percentToClose, currentPrice, context);
         };
+        /**
+         * Adjusts the trailing stop-loss distance for an active pending signal.
+         *
+         * Validates strategy existence and delegates to connection service
+         * to update the stop-loss distance by a percentage adjustment.
+         *
+         * Does not require execution context as this is a direct state mutation.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise that resolves when trailing SL is updated
+         *
+         * @example
+         * ```typescript
+         * // LONG: entry=100, originalSL=90, distance=10
+         * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
+         * await strategyCoreService.trailingStop(
+         *   false,
+         *   "BTCUSDT",
+         *   -50,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+         * );
+         * ```
+         */
+        this.trailingStop = async (backtest, symbol, percentShift, context) => {
+            this.loggerService.log("strategyCoreService trailingStop", {
+                symbol,
+                percentShift,
+                context,
+                backtest,
+            });
+            await this.validate(symbol, context);
+            return await this.strategyConnectionService.trailingStop(backtest, symbol, percentShift, context);
+        };
     }
 }
 
@@ -7036,6 +7537,104 @@ class LiveLogicPrivateService {
     }
 }
 
+/**
+ * Wrapper to call onStrategyStart callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param walkerSchema - Walker schema containing callbacks
+ * @param strategyName - Name of the strategy being tested
+ * @param symbol - Trading pair symbol
+ */
+const CALL_STRATEGY_START_CALLBACKS_FN = functoolsKit.trycatch(async (walkerSchema, strategyName, symbol) => {
+    if (walkerSchema.callbacks?.onStrategyStart) {
+        await walkerSchema.callbacks.onStrategyStart(strategyName, symbol);
+    }
+}, {
+    fallback: (error) => {
+        const message = "WalkerLogicPrivateService CALL_STRATEGY_START_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Wrapper to call onStrategyError callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param walkerSchema - Walker schema containing callbacks
+ * @param strategyName - Name of the strategy that failed
+ * @param symbol - Trading pair symbol
+ * @param error - Error that occurred during strategy execution
+ */
+const CALL_STRATEGY_ERROR_CALLBACKS_FN = functoolsKit.trycatch(async (walkerSchema, strategyName, symbol, error) => {
+    if (walkerSchema.callbacks?.onStrategyError) {
+        await walkerSchema.callbacks.onStrategyError(strategyName, symbol, error);
+    }
+}, {
+    fallback: (error) => {
+        const message = "WalkerLogicPrivateService CALL_STRATEGY_ERROR_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Wrapper to call onStrategyComplete callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param walkerSchema - Walker schema containing callbacks
+ * @param strategyName - Name of the strategy that completed
+ * @param symbol - Trading pair symbol
+ * @param stats - Backtest statistics for the strategy
+ * @param metricValue - Calculated metric value for comparison
+ */
+const CALL_STRATEGY_COMPLETE_CALLBACKS_FN = functoolsKit.trycatch(async (walkerSchema, strategyName, symbol, stats, metricValue) => {
+    if (walkerSchema.callbacks?.onStrategyComplete) {
+        await walkerSchema.callbacks.onStrategyComplete(strategyName, symbol, stats, metricValue);
+    }
+}, {
+    fallback: (error) => {
+        const message = "WalkerLogicPrivateService CALL_STRATEGY_COMPLETE_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Wrapper to call onComplete callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param walkerSchema - Walker schema containing callbacks
+ * @param finalResults - Final results with all strategies ranked
+ */
+const CALL_COMPLETE_CALLBACKS_FN = functoolsKit.trycatch(async (walkerSchema, finalResults) => {
+    if (walkerSchema.callbacks?.onComplete) {
+        await walkerSchema.callbacks.onComplete(finalResults);
+    }
+}, {
+    fallback: (error) => {
+        const message = "WalkerLogicPrivateService CALL_COMPLETE_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Private service for walker orchestration (strategy comparison).
  *
@@ -7121,9 +7720,7 @@ class WalkerLogicPrivateService {
                     break;
                 }
                 // Call onStrategyStart callback if provided
-                if (walkerSchema.callbacks?.onStrategyStart) {
-                    walkerSchema.callbacks.onStrategyStart(strategyName, symbol);
-                }
+                await CALL_STRATEGY_START_CALLBACKS_FN(walkerSchema, strategyName, symbol);
                 this.loggerService.info("walkerLogicPrivateService testing strategy", {
                     strategyName,
                     symbol,
@@ -7145,9 +7742,7 @@ class WalkerLogicPrivateService {
                     });
                     await errorEmitter.next(error);
                     // Call onStrategyError callback if provided
-                    if (walkerSchema.callbacks?.onStrategyError) {
-                        walkerSchema.callbacks.onStrategyError(strategyName, symbol, error);
-                    }
+                    await CALL_STRATEGY_ERROR_CALLBACKS_FN(walkerSchema, strategyName, symbol, error);
                     continue;
                 }
                 this.loggerService.info("walkerLogicPrivateService backtest complete", {
@@ -7198,9 +7793,7 @@ class WalkerLogicPrivateService {
                     progress: strategies.length > 0 ? strategiesTested / strategies.length : 0,
                 });
                 // Call onStrategyComplete callback if provided
-                if (walkerSchema.callbacks?.onStrategyComplete) {
-                    await walkerSchema.callbacks.onStrategyComplete(strategyName, symbol, stats, metricValue);
-                }
+                await CALL_STRATEGY_COMPLETE_CALLBACKS_FN(walkerSchema, strategyName, symbol, stats, metricValue);
                 await walkerEmitter.next(walkerContract);
                 yield walkerContract;
             }
@@ -7223,9 +7816,7 @@ class WalkerLogicPrivateService {
                 : null,
         };
         // Call onComplete callback if provided with final best results
-        if (walkerSchema.callbacks?.onComplete) {
-            walkerSchema.callbacks.onComplete(finalResults);
-        }
+        await CALL_COMPLETE_CALLBACKS_FN(walkerSchema, finalResults);
         await walkerCompleteSubject.next(finalResults);
     }
 }
@@ -8988,7 +9579,7 @@ class BacktestMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("backtestMarkdownService init");
-            signalBacktestEmitter.subscribe(this.tick);
+            this.unsubscribe = signalBacktestEmitter.subscribe(this.tick);
         });
     }
 }
@@ -9517,7 +10108,7 @@ class LiveMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("liveMarkdownService init");
-            signalLiveEmitter.subscribe(this.tick);
+            this.unsubscribe = signalLiveEmitter.subscribe(this.tick);
         });
     }
 }
@@ -9946,7 +10537,7 @@ class ScheduleMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("scheduleMarkdownService init");
-            signalEmitter.subscribe(this.tick);
+            this.unsubscribe = signalEmitter.subscribe(this.tick);
         });
     }
 }
@@ -10314,7 +10905,7 @@ class PerformanceMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("performanceMarkdownService init");
-            performanceEmitter.subscribe(this.track);
+            this.unsubscribe = performanceEmitter.subscribe(this.track);
         });
     }
 }
@@ -10723,7 +11314,7 @@ class WalkerMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("walkerMarkdownService init");
-            walkerEmitter.subscribe(this.tick);
+            this.unsubscribe = walkerEmitter.subscribe(this.tick);
         });
     }
 }
@@ -11250,7 +11841,7 @@ class HeatMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("heatMarkdownService init");
-            signalEmitter.subscribe(this.tick);
+            this.unsubscribe = signalEmitter.subscribe(this.tick);
         });
     }
 }
@@ -14014,8 +14605,9 @@ class PartialMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("partialMarkdownService init");
-            partialProfitSubject.subscribe(this.tickProfit);
-            partialLossSubject.subscribe(this.tickLoss);
+            const unProfit = partialProfitSubject.subscribe(this.tickProfit);
+            const unLoss = partialLossSubject.subscribe(this.tickLoss);
+            this.unsubscribe = functoolsKit.compose(() => unProfit(), () => unLoss());
         });
     }
 }
@@ -14760,7 +15352,7 @@ class RiskMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("riskMarkdownService init");
-            riskSubject.subscribe(this.tickRejection);
+            this.unsubscribe = riskSubject.subscribe(this.tickRejection);
         });
     }
 }
@@ -15419,6 +16011,7 @@ const STOP_METHOD_NAME = "strategy.stop";
 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";
 /**
  * Stops the strategy from generating new signals.
  *
@@ -15575,6 +16168,42 @@ async function partialLoss(symbol, percentToClose) {
     const { exchangeName, frameName, strategyName } = backtest$1.methodContextService.context;
     await backtest$1.strategyCoreService.partialLoss(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
 }
+/**
+ * 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.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+ * @returns Promise that resolves when trailing SL is updated
+ *
+ * @example
+ * ```typescript
+ * import { trailingStop } from "backtest-kit";
+ *
+ * // LONG: entry=100, originalSL=90, distance=10
+ * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
+ * await trailingStop("BTCUSDT", -50);
+ * ```
+ */
+async function trailingStop(symbol, percentShift) {
+    backtest$1.loggerService.info(TRAILING_STOP_METHOD_NAME, {
+        symbol,
+        percentShift,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("trailingStop requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("trailingStop requires a method context");
+    }
+    const { backtest: isBacktest } = backtest$1.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest$1.methodContextService.context;
+    await backtest$1.strategyCoreService.trailingStop(isBacktest, symbol, percentShift, { exchangeName, frameName, strategyName });
+}
 
 /**
  * Sets custom logger implementation for the framework.
@@ -17412,6 +18041,7 @@ const BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL = "BacktestUtils.getScheduledSig
 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_GET_DATA = "BacktestUtils.getData";
 /**
  * Internal task function that runs backtest and handles completion.
@@ -17980,6 +18610,44 @@ class BacktestUtils {
             }
             await backtest$1.strategyCoreService.partialLoss(true, symbol, percentToClose, currentPrice, context);
         };
+        /**
+         * 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.
+         *
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Promise that resolves when trailing SL is updated
+         *
+         * @example
+         * ```typescript
+         * // LONG: entry=100, originalSL=90, distance=10
+         * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
+         * await Backtest.trailingStop("BTCUSDT", -50, {
+         *   exchangeName: "binance",
+         *   frameName: "frame1",
+         *   strategyName: "my-strategy"
+         * });
+         * ```
+         */
+        this.trailingStop = async (symbol, percentShift, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_TRAILING_STOP, {
+                symbol,
+                percentShift,
+                context,
+            });
+            backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_TRAILING_STOP);
+            {
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_TRAILING_STOP);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_TRAILING_STOP));
+            }
+            await backtest$1.strategyCoreService.trailingStop(true, symbol, percentShift, context);
+        };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
          *
@@ -18141,6 +18809,7 @@ const LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL = "LiveUtils.getScheduledSignal";
 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";
 /**
  * Internal task function that runs live trading and handles completion.
  * Consumes live trading results and updates instance state flags.
@@ -18685,6 +19354,45 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * 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.
+         *
+         * @param symbol - Trading pair symbol
+         * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise that resolves when trailing SL is updated
+         *
+         * @example
+         * ```typescript
+         * // LONG: entry=100, originalSL=90, distance=10
+         * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
+         * await Live.trailingStop("BTCUSDT", -50, {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy"
+         * });
+         * ```
+         */
+        this.trailingStop = async (symbol, percentShift, context) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_TRAILING_STOP, {
+                symbol,
+                percentShift,
+                context,
+            });
+            backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_TRAILING_STOP);
+            {
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_STOP);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_TRAILING_STOP));
+            }
+            await backtest$1.strategyCoreService.trailingStop(false, symbol, percentShift, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
          *
@@ -21387,4 +22095,5 @@ exports.setColumns = setColumns;
 exports.setConfig = setConfig;
 exports.setLogger = setLogger;
 exports.stop = stop;
+exports.trailingStop = trailingStop;
 exports.validate = validate;