backtest-kit 1.8.1 → 1.9.1

package/build/index.mjs

@@ -1,6 +1,6 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, isObject, ToolRegistry, and, resolveDocuments, str, iterateDocuments, distinctDocuments, queued, singlerun } from 'functools-kit';
+import { Subject, trycatch, errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, retry, randomString, isObject, ToolRegistry, and, resolveDocuments, str, iterateDocuments, distinctDocuments, compose, queued, singlerun } from 'functools-kit';
 import fs, { mkdir, writeFile } from 'fs/promises';
 import path, { join } from 'path';
 import crypto from 'crypto';
@@ -361,6 +361,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 Subject();
+/**
+ * Live trading signal emitter.
+ * Emits only signals from live trading execution.
+ */
+const signalLiveEmitter = new Subject();
+/**
+ * Backtest signal emitter.
+ * Emits only signals from backtest execution.
+ */
+const signalBacktestEmitter = new Subject();
+/**
+ * Error emitter for background execution errors.
+ * Emits errors caught in background tasks (Live.background, Backtest.background).
+ */
+const errorEmitter = new 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 Subject();
+/**
+ * Done emitter for live background execution completion.
+ * Emits when live background tasks complete (Live.background).
+ */
+const doneLiveSubject = new Subject();
+/**
+ * Done emitter for backtest background execution completion.
+ * Emits when backtest background tasks complete (Backtest.background).
+ */
+const doneBacktestSubject = new Subject();
+/**
+ * Done emitter for walker background execution completion.
+ * Emits when walker background tasks complete (Walker.background).
+ */
+const doneWalkerSubject = new Subject();
+/**
+ * Progress emitter for backtest execution progress.
+ * Emits progress updates during backtest execution.
+ */
+const progressBacktestEmitter = new Subject();
+/**
+ * Progress emitter for walker execution progress.
+ * Emits progress updates during walker execution.
+ */
+const progressWalkerEmitter = new Subject();
+/**
+ * Progress emitter for optimizer execution progress.
+ * Emits progress updates during optimizer execution.
+ */
+const progressOptimizerEmitter = new Subject();
+/**
+ * Performance emitter for execution metrics.
+ * Emits performance metrics for profiling and bottleneck detection.
+ */
+const performanceEmitter = new Subject();
+/**
+ * Walker emitter for strategy comparison progress.
+ * Emits progress updates during walker execution (each strategy completion).
+ */
+const walkerEmitter = new Subject();
+/**
+ * Walker complete emitter for strategy comparison completion.
+ * Emits when all strategies have been tested and final results are available.
+ */
+const walkerCompleteSubject = new 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 Subject();
+/**
+ * Validation emitter for risk validation errors.
+ * Emits when risk validation functions throw errors during signal checking.
+ */
+const validationSubject = new Subject();
+/**
+ * Partial profit emitter for profit level milestones.
+ * Emits when a signal reaches a profit level (10%, 20%, 30%, etc).
+ */
+const partialProfitSubject = new Subject();
+/**
+ * Partial loss emitter for loss level milestones.
+ * Emits when a signal reaches a loss level (10%, 20%, 30%, etc).
+ */
+const partialLossSubject = new 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 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 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,
@@ -462,6 +592,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 = 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Client implementation for exchange data access.
  *
@@ -520,9 +677,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;
     }
     /**
@@ -557,9 +712,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;
     }
     /**
@@ -1736,136 +1889,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 Subject();
-/**
- * Live trading signal emitter.
- * Emits only signals from live trading execution.
- */
-const signalLiveEmitter = new Subject();
-/**
- * Backtest signal emitter.
- * Emits only signals from backtest execution.
- */
-const signalBacktestEmitter = new Subject();
-/**
- * Error emitter for background execution errors.
- * Emits errors caught in background tasks (Live.background, Backtest.background).
- */
-const errorEmitter = new 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 Subject();
-/**
- * Done emitter for live background execution completion.
- * Emits when live background tasks complete (Live.background).
- */
-const doneLiveSubject = new Subject();
-/**
- * Done emitter for backtest background execution completion.
- * Emits when backtest background tasks complete (Backtest.background).
- */
-const doneBacktestSubject = new Subject();
-/**
- * Done emitter for walker background execution completion.
- * Emits when walker background tasks complete (Walker.background).
- */
-const doneWalkerSubject = new Subject();
-/**
- * Progress emitter for backtest execution progress.
- * Emits progress updates during backtest execution.
- */
-const progressBacktestEmitter = new Subject();
-/**
- * Progress emitter for walker execution progress.
- * Emits progress updates during walker execution.
- */
-const progressWalkerEmitter = new Subject();
-/**
- * Progress emitter for optimizer execution progress.
- * Emits progress updates during optimizer execution.
- */
-const progressOptimizerEmitter = new Subject();
-/**
- * Performance emitter for execution metrics.
- * Emits performance metrics for profiling and bottleneck detection.
- */
-const performanceEmitter = new Subject();
-/**
- * Walker emitter for strategy comparison progress.
- * Emits progress updates during walker execution (each strategy completion).
- */
-const walkerEmitter = new Subject();
-/**
- * Walker complete emitter for strategy comparison completion.
- * Emits when all strategies have been tested and final results are available.
- */
-const walkerCompleteSubject = new 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 Subject();
-/**
- * Validation emitter for risk validation errors.
- * Emits when risk validation functions throw errors during signal checking.
- */
-const validationSubject = new Subject();
-/**
- * Partial profit emitter for profit level milestones.
- * Emits when a signal reaches a profit level (10%, 20%, 30%, etc).
- */
-const partialProfitSubject = new Subject();
-/**
- * Partial loss emitter for loss level milestones.
- * Emits when a signal reaches a loss level (10%, 20%, 30%, etc).
- */
-const partialLossSubject = new 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 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 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
@@ -1922,227 +1945,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) {
@@ -2382,6 +2499,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
@@ -2400,7 +2608,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,
@@ -2455,7 +2663,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,
@@ -2512,7 +2720,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,
@@ -2525,11 +2733,12 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
 };
 const CALL_PING_CALLBACKS_FN = 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),
@@ -2551,7 +2760,8 @@ const CALL_PING_CALLBACKS_FN = trycatch(async (self, symbol, scheduled, timestam
 const CALL_ACTIVE_CALLBACKS_FN = 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),
@@ -2573,7 +2783,8 @@ const CALL_ACTIVE_CALLBACKS_FN = trycatch(async (self, symbol, signal, currentPr
 const CALL_SCHEDULE_CALLBACKS_FN = 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),
@@ -2595,7 +2806,8 @@ const CALL_SCHEDULE_CALLBACKS_FN = trycatch(async (self, symbol, signal, current
 const CALL_CANCEL_CALLBACKS_FN = 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),
@@ -2617,7 +2829,8 @@ const CALL_CANCEL_CALLBACKS_FN = trycatch(async (self, symbol, signal, currentPr
 const CALL_OPEN_CALLBACKS_FN = 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),
@@ -2639,7 +2852,8 @@ const CALL_OPEN_CALLBACKS_FN = trycatch(async (self, symbol, signal, priceOpen,
 const CALL_CLOSE_CALLBACKS_FN = 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),
@@ -2661,7 +2875,7 @@ const CALL_CLOSE_CALLBACKS_FN = trycatch(async (self, symbol, signal, currentPri
 const CALL_TICK_CALLBACKS_FN = 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),
@@ -2683,7 +2897,7 @@ const CALL_TICK_CALLBACKS_FN = trycatch(async (self, symbol, result, timestamp,
 const CALL_IDLE_CALLBACKS_FN = 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),
@@ -2754,7 +2968,8 @@ const CALL_RISK_REMOVE_SIGNAL_FN = trycatch(async (self, symbol, timestamp, back
 });
 const CALL_PARTIAL_CLEAR_FN = 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,
@@ -2803,9 +3018,10 @@ const CALL_RISK_CHECK_SIGNAL_FN = trycatch(async (self, symbol, pendingSignal, c
 });
 const CALL_PARTIAL_PROFIT_CALLBACKS_FN = 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),
@@ -2826,9 +3042,10 @@ const CALL_PARTIAL_PROFIT_CALLBACKS_FN = trycatch(async (self, symbol, signal, c
 });
 const CALL_PARTIAL_LOSS_CALLBACKS_FN = 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),
@@ -2852,7 +3069,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,
@@ -2878,7 +3095,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,
@@ -2898,7 +3115,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,
@@ -2927,13 +3144,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;
@@ -2955,7 +3173,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,
@@ -2986,8 +3204,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);
@@ -3004,8 +3223,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);
@@ -3014,7 +3234,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,
@@ -3056,7 +3276,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,
@@ -3133,7 +3353,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,
@@ -3257,13 +3477,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";
             }
@@ -3274,7 +3496,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";
             }
@@ -3286,7 +3508,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);
         }
@@ -3303,8 +3525,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);
                 }
@@ -3319,8 +3542,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);
                 }
@@ -3392,7 +3616,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;
@@ -3427,7 +3652,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.
@@ -3438,7 +3663,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.
@@ -3511,7 +3736,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,
@@ -3624,7 +3849,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,
@@ -3686,7 +3911,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,
@@ -3891,7 +4116,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);
@@ -3983,7 +4208,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);
@@ -4657,40 +4965,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);
         };
     }
 }
@@ -4714,6 +5058,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 = 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: errorData(error),
+            message: 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.
@@ -4743,9 +5113,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;
 };
 /**
@@ -4904,6 +5272,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 = 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: errorData(error),
+            message: 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.
@@ -4957,9 +5349,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;
 };
 /**
@@ -5075,6 +5465,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 */
@@ -5094,6 +5528,40 @@ const DO_VALIDATION_FN = async (validation, params) => {
         return payload.message;
     }
 };
+/** Wrapper to call onRejected callback with error handling */
+const CALL_REJECTED_CALLBACKS_FN = 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: errorData(error),
+            message: 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 = 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: errorData(error),
+            message: 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.
@@ -5164,6 +5632,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()),
             };
@@ -5198,15 +5667,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;
         };
     }
@@ -5894,6 +6359,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);
+        };
     }
 }
 
@@ -7034,6 +7535,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 = 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: errorData(error),
+            message: 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 = 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: errorData(error),
+            message: 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 = 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: errorData(error),
+            message: 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 = 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Private service for walker orchestration (strategy comparison).
  *
@@ -7119,9 +7718,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,
@@ -7143,9 +7740,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", {
@@ -7196,9 +7791,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;
             }
@@ -7221,9 +7814,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);
     }
 }
@@ -8986,7 +9577,7 @@ class BacktestMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("backtestMarkdownService init");
-            signalBacktestEmitter.subscribe(this.tick);
+            this.unsubscribe = signalBacktestEmitter.subscribe(this.tick);
         });
     }
 }
@@ -9515,7 +10106,7 @@ class LiveMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("liveMarkdownService init");
-            signalLiveEmitter.subscribe(this.tick);
+            this.unsubscribe = signalLiveEmitter.subscribe(this.tick);
         });
     }
 }
@@ -9944,7 +10535,7 @@ class ScheduleMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("scheduleMarkdownService init");
-            signalEmitter.subscribe(this.tick);
+            this.unsubscribe = signalEmitter.subscribe(this.tick);
         });
     }
 }
@@ -10312,7 +10903,7 @@ class PerformanceMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("performanceMarkdownService init");
-            performanceEmitter.subscribe(this.track);
+            this.unsubscribe = performanceEmitter.subscribe(this.track);
         });
     }
 }
@@ -10721,7 +11312,7 @@ class WalkerMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("walkerMarkdownService init");
-            walkerEmitter.subscribe(this.tick);
+            this.unsubscribe = walkerEmitter.subscribe(this.tick);
         });
     }
 }
@@ -11248,7 +11839,7 @@ class HeatMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("heatMarkdownService init");
-            signalEmitter.subscribe(this.tick);
+            this.unsubscribe = signalEmitter.subscribe(this.tick);
         });
     }
 }
@@ -14012,8 +14603,9 @@ class PartialMarkdownService {
          */
         this.init = 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 = compose(() => unProfit(), () => unLoss());
         });
     }
 }
@@ -14758,7 +15350,7 @@ class RiskMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("riskMarkdownService init");
-            riskSubject.subscribe(this.tickRejection);
+            this.unsubscribe = riskSubject.subscribe(this.tickRejection);
         });
     }
 }
@@ -15417,6 +16009,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.
  *
@@ -15573,6 +16166,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.
@@ -17410,6 +18039,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.
@@ -17978,6 +18608,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.
          *
@@ -18139,6 +18807,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.
@@ -18683,6 +19352,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.
          *
@@ -21299,4 +22007,4 @@ class NotificationUtils {
  */
 const Notification = new NotificationUtils();
 
-export { Backtest, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, cancel, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getColumns, getConfig, getDate, getDefaultColumns, getDefaultConfig, getMode, hasTradeContext, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenPing, listenPingOnce, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, partialLoss, partialProfit, setColumns, setConfig, setLogger, stop, validate };
+export { Backtest, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, cancel, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getColumns, getConfig, getDate, getDefaultColumns, getDefaultConfig, getMode, hasTradeContext, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenPing, listenPingOnce, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, partialLoss, partialProfit, setColumns, setConfig, setLogger, stop, trailingStop, validate };