backtest-kit 1.7.2 → 1.9.1

package/build/index.cjs

@@ -363,6 +363,136 @@ const GLOBAL_CONFIG = {
 };
 const DEFAULT_CONFIG = Object.freeze({ ...GLOBAL_CONFIG });
 
+/**
+ * Global signal emitter for all trading events (live + backtest).
+ * Emits all signal events regardless of execution mode.
+ */
+const signalEmitter = new functoolsKit.Subject();
+/**
+ * Live trading signal emitter.
+ * Emits only signals from live trading execution.
+ */
+const signalLiveEmitter = new functoolsKit.Subject();
+/**
+ * Backtest signal emitter.
+ * Emits only signals from backtest execution.
+ */
+const signalBacktestEmitter = new functoolsKit.Subject();
+/**
+ * Error emitter for background execution errors.
+ * Emits errors caught in background tasks (Live.background, Backtest.background).
+ */
+const errorEmitter = new functoolsKit.Subject();
+/**
+ * Exit emitter for critical errors that require process termination.
+ * Emits errors that should terminate the current execution (Backtest, Live, Walker).
+ * Unlike errorEmitter (for recoverable errors), exitEmitter signals fatal errors.
+ */
+const exitEmitter = new functoolsKit.Subject();
+/**
+ * Done emitter for live background execution completion.
+ * Emits when live background tasks complete (Live.background).
+ */
+const doneLiveSubject = new functoolsKit.Subject();
+/**
+ * Done emitter for backtest background execution completion.
+ * Emits when backtest background tasks complete (Backtest.background).
+ */
+const doneBacktestSubject = new functoolsKit.Subject();
+/**
+ * Done emitter for walker background execution completion.
+ * Emits when walker background tasks complete (Walker.background).
+ */
+const doneWalkerSubject = new functoolsKit.Subject();
+/**
+ * Progress emitter for backtest execution progress.
+ * Emits progress updates during backtest execution.
+ */
+const progressBacktestEmitter = new functoolsKit.Subject();
+/**
+ * Progress emitter for walker execution progress.
+ * Emits progress updates during walker execution.
+ */
+const progressWalkerEmitter = new functoolsKit.Subject();
+/**
+ * Progress emitter for optimizer execution progress.
+ * Emits progress updates during optimizer execution.
+ */
+const progressOptimizerEmitter = new functoolsKit.Subject();
+/**
+ * Performance emitter for execution metrics.
+ * Emits performance metrics for profiling and bottleneck detection.
+ */
+const performanceEmitter = new functoolsKit.Subject();
+/**
+ * Walker emitter for strategy comparison progress.
+ * Emits progress updates during walker execution (each strategy completion).
+ */
+const walkerEmitter = new functoolsKit.Subject();
+/**
+ * Walker complete emitter for strategy comparison completion.
+ * Emits when all strategies have been tested and final results are available.
+ */
+const walkerCompleteSubject = new functoolsKit.Subject();
+/**
+ * Walker stop emitter for walker cancellation events.
+ * Emits when a walker comparison is stopped/cancelled.
+ *
+ * Includes walkerName to support multiple walkers running on the same symbol.
+ */
+const walkerStopSubject = new functoolsKit.Subject();
+/**
+ * Validation emitter for risk validation errors.
+ * Emits when risk validation functions throw errors during signal checking.
+ */
+const validationSubject = new functoolsKit.Subject();
+/**
+ * Partial profit emitter for profit level milestones.
+ * Emits when a signal reaches a profit level (10%, 20%, 30%, etc).
+ */
+const partialProfitSubject = new functoolsKit.Subject();
+/**
+ * Partial loss emitter for loss level milestones.
+ * Emits when a signal reaches a loss level (10%, 20%, 30%, etc).
+ */
+const partialLossSubject = new functoolsKit.Subject();
+/**
+ * Risk rejection emitter for risk management violations.
+ * Emits ONLY when a signal is rejected due to risk validation failure.
+ * Does not emit for allowed signals (prevents spam).
+ */
+const riskSubject = new functoolsKit.Subject();
+/**
+ * Ping emitter for scheduled signal monitoring events.
+ * Emits every minute when a scheduled signal is being monitored (waiting for activation).
+ * Allows users to track scheduled signal lifecycle and implement custom cancellation logic.
+ */
+const pingSubject = new functoolsKit.Subject();
+
+var emitters = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    doneBacktestSubject: doneBacktestSubject,
+    doneLiveSubject: doneLiveSubject,
+    doneWalkerSubject: doneWalkerSubject,
+    errorEmitter: errorEmitter,
+    exitEmitter: exitEmitter,
+    partialLossSubject: partialLossSubject,
+    partialProfitSubject: partialProfitSubject,
+    performanceEmitter: performanceEmitter,
+    pingSubject: pingSubject,
+    progressBacktestEmitter: progressBacktestEmitter,
+    progressOptimizerEmitter: progressOptimizerEmitter,
+    progressWalkerEmitter: progressWalkerEmitter,
+    riskSubject: riskSubject,
+    signalBacktestEmitter: signalBacktestEmitter,
+    signalEmitter: signalEmitter,
+    signalLiveEmitter: signalLiveEmitter,
+    validationSubject: validationSubject,
+    walkerCompleteSubject: walkerCompleteSubject,
+    walkerEmitter: walkerEmitter,
+    walkerStopSubject: walkerStopSubject
+});
+
 const INTERVAL_MINUTES$4 = {
     "1m": 1,
     "3m": 3,
@@ -464,6 +594,33 @@ const GET_CANDLES_FN = async (dto, since, self) => {
     }
     throw lastError;
 };
+/**
+ * Wrapper to call onCandleData callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param self - ClientExchange instance reference
+ * @param symbol - Trading pair symbol
+ * @param interval - Candle interval
+ * @param since - Start date for candle data
+ * @param limit - Number of candles
+ * @param data - Array of candle data
+ */
+const CALL_CANDLE_DATA_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, interval, since, limit, data) => {
+    if (self.params.callbacks?.onCandleData) {
+        await self.params.callbacks.onCandleData(symbol, interval, since, limit, data);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientExchange CALL_CANDLE_DATA_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Client implementation for exchange data access.
  *
@@ -522,9 +679,7 @@ class ClientExchange {
         if (filteredData.length < limit) {
             this.params.logger.warn(`ClientExchange Expected ${limit} candles, got ${filteredData.length}`);
         }
-        if (this.params.callbacks?.onCandleData) {
-            this.params.callbacks.onCandleData(symbol, interval, since, limit, filteredData);
-        }
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, filteredData);
         return filteredData;
     }
     /**
@@ -559,9 +714,7 @@ class ClientExchange {
         if (filteredData.length < limit) {
             this.params.logger.warn(`ClientExchange getNextCandles: Expected ${limit} candles, got ${filteredData.length}`);
         }
-        if (this.params.callbacks?.onCandleData) {
-            this.params.callbacks.onCandleData(symbol, interval, since, limit, filteredData);
-        }
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, filteredData);
         return filteredData;
     }
     /**
@@ -772,6 +925,11 @@ class ExchangeConnectionService {
 /**
  * Calculates profit/loss for a closed signal with slippage and fees.
  *
+ * For signals with partial closes:
+ * - Calculates weighted PNL: Σ(percent_i × pnl_i) for each partial + (remaining% × final_pnl)
+ * - Each partial close has its own fees and slippage
+ * - Total fees = 2 × (number of partial closes + 1 final close) × CC_PERCENT_FEE
+ *
  * Formula breakdown:
  * 1. Apply slippage to open/close prices (worse execution)
  *    - LONG: buy higher (+slippage), sell lower (-slippage)
@@ -779,27 +937,113 @@ class ExchangeConnectionService {
  * 2. Calculate raw PNL percentage
  *    - LONG: ((closePrice - openPrice) / openPrice) * 100
  *    - SHORT: ((openPrice - closePrice) / openPrice) * 100
- * 3. Subtract total fees (0.1% * 2 = 0.2%)
+ * 3. Subtract total fees (0.1% * 2 = 0.2% per transaction)
  *
- * @param signal - Closed signal with position details
- * @param priceClose - Actual close price at exit
+ * @param signal - Closed signal with position details and optional partial history
+ * @param priceClose - Actual close price at final exit
  * @returns PNL data with percentage and prices
  *
  * @example
  * ```typescript
+ * // Signal without partial closes
  * const pnl = toProfitLossDto(
  *   {
  *     position: "long",
- *     priceOpen: 50000,
- *     // ... other signal fields
+ *     priceOpen: 100,
+ *   },
+ *   110 // close at +10%
+ * );
+ * console.log(pnl.pnlPercentage); // ~9.6% (after slippage and fees)
+ *
+ * // Signal with partial closes
+ * const pnlPartial = toProfitLossDto(
+ *   {
+ *     position: "long",
+ *     priceOpen: 100,
+ *     _partial: [
+ *       { type: "profit", percent: 30, price: 120 }, // +20% on 30%
+ *       { type: "profit", percent: 40, price: 115 }, // +15% on 40%
+ *     ],
  *   },
- *   51000 // close price
+ *   105 // final close at +5% for remaining 30%
  * );
- * console.log(pnl.pnlPercentage); // e.g., 1.8% (after slippage and fees)
+ * // Weighted PNL = 30% × 20% + 40% × 15% + 30% × 5% = 6% + 6% + 1.5% = 13.5% (before fees)
  * ```
  */
 const toProfitLossDto = (signal, priceClose) => {
     const priceOpen = signal.priceOpen;
+    // Calculate weighted PNL with partial closes
+    if (signal._partial && signal._partial.length > 0) {
+        let totalWeightedPnl = 0;
+        let totalFees = 0;
+        // Calculate PNL for each partial close
+        for (const partial of signal._partial) {
+            const partialPercent = partial.percent;
+            const partialPrice = partial.price;
+            // Apply slippage to prices
+            let priceOpenWithSlippage;
+            let priceCloseWithSlippage;
+            if (signal.position === "long") {
+                priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+                priceCloseWithSlippage = partialPrice * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+            }
+            else {
+                priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+                priceCloseWithSlippage = partialPrice * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+            }
+            // Calculate PNL for this partial
+            let partialPnl;
+            if (signal.position === "long") {
+                partialPnl = ((priceCloseWithSlippage - priceOpenWithSlippage) / priceOpenWithSlippage) * 100;
+            }
+            else {
+                partialPnl = ((priceOpenWithSlippage - priceCloseWithSlippage) / priceOpenWithSlippage) * 100;
+            }
+            // Weight by percentage of position closed
+            const weightedPnl = (partialPercent / 100) * partialPnl;
+            totalWeightedPnl += weightedPnl;
+            // Each partial has fees for open + close (2 transactions)
+            totalFees += GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
+        }
+        // Calculate PNL for remaining position (if any)
+        // Compute totalClosed from _partial array
+        const totalClosed = signal._partial.reduce((sum, p) => sum + p.percent, 0);
+        const remainingPercent = 100 - totalClosed;
+        if (remainingPercent > 0) {
+            // Apply slippage
+            let priceOpenWithSlippage;
+            let priceCloseWithSlippage;
+            if (signal.position === "long") {
+                priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+                priceCloseWithSlippage = priceClose * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+            }
+            else {
+                priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+                priceCloseWithSlippage = priceClose * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+            }
+            // Calculate PNL for remaining
+            let remainingPnl;
+            if (signal.position === "long") {
+                remainingPnl = ((priceCloseWithSlippage - priceOpenWithSlippage) / priceOpenWithSlippage) * 100;
+            }
+            else {
+                remainingPnl = ((priceOpenWithSlippage - priceCloseWithSlippage) / priceOpenWithSlippage) * 100;
+            }
+            // Weight by remaining percentage
+            const weightedRemainingPnl = (remainingPercent / 100) * remainingPnl;
+            totalWeightedPnl += weightedRemainingPnl;
+            // Final close also has fees
+            totalFees += GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
+        }
+        // Subtract total fees from weighted PNL
+        const pnlPercentage = totalWeightedPnl - totalFees;
+        return {
+            pnlPercentage,
+            priceOpen,
+            priceClose,
+        };
+    }
+    // Original logic for signals without partial closes
     let priceOpenWithSlippage;
     let priceCloseWithSlippage;
     if (signal.position === "long") {
@@ -1648,412 +1892,376 @@ class PersistPartialUtils {
 const PersistPartialAdapter = new PersistPartialUtils();
 
 /**
- * Global signal emitter for all trading events (live + backtest).
- * Emits all signal events regardless of execution mode.
- */
-const signalEmitter = new functoolsKit.Subject();
-/**
- * Live trading signal emitter.
- * Emits only signals from live trading execution.
- */
-const signalLiveEmitter = new functoolsKit.Subject();
-/**
- * Backtest signal emitter.
- * Emits only signals from backtest execution.
+ * Converts markdown content to plain text with minimal formatting
+ * @param content - Markdown string to convert
+ * @returns Plain text representation
  */
-const signalBacktestEmitter = new functoolsKit.Subject();
+const toPlainString = (content) => {
+    if (!content) {
+        return "";
+    }
+    let text = content;
+    // Remove code blocks
+    text = text.replace(/```[\s\S]*?```/g, "");
+    text = text.replace(/`([^`]+)`/g, "$1");
+    // Remove images
+    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1");
+    // Convert links to text only (keep link text, remove URL)
+    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    // Remove headers (convert to plain text)
+    text = text.replace(/^#{1,6}\s+(.+)$/gm, "$1");
+    // Remove bold and italic markers
+    text = text.replace(/\*\*\*(.+?)\*\*\*/g, "$1");
+    text = text.replace(/\*\*(.+?)\*\*/g, "$1");
+    text = text.replace(/\*(.+?)\*/g, "$1");
+    text = text.replace(/___(.+?)___/g, "$1");
+    text = text.replace(/__(.+?)__/g, "$1");
+    text = text.replace(/_(.+?)_/g, "$1");
+    // Remove strikethrough
+    text = text.replace(/~~(.+?)~~/g, "$1");
+    // Convert lists to plain text with bullets
+    text = text.replace(/^\s*[-*+]\s+/gm, "• ");
+    text = text.replace(/^\s*\d+\.\s+/gm, "• ");
+    // Remove blockquotes
+    text = text.replace(/^\s*>\s+/gm, "");
+    // Remove horizontal rules
+    text = text.replace(/^(\*{3,}|-{3,}|_{3,})$/gm, "");
+    // Remove HTML tags
+    text = text.replace(/<[^>]+>/g, "");
+    // Remove excessive whitespace and normalize line breaks
+    text = text.replace(/\n[\s\n]*\n/g, "\n");
+    text = text.replace(/[ \t]+/g, " ");
+    // Remove all newline characters
+    text = text.replace(/\n/g, " ");
+    // Remove excessive spaces after newline removal
+    text = text.replace(/\s+/g, " ");
+    return text.trim();
+};
+
+const INTERVAL_MINUTES$3 = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+};
+const TIMEOUT_SYMBOL = Symbol('timeout');
 /**
- * Error emitter for background execution errors.
- * Emits errors caught in background tasks (Live.background, Backtest.background).
+ * 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 errorEmitter = new functoolsKit.Subject();
-/**
- * Exit emitter for critical errors that require process termination.
- * Emits errors that should terminate the current execution (Backtest, Live, Walker).
- * Unlike errorEmitter (for recoverable errors), exitEmitter signals fatal errors.
- */
-const exitEmitter = new functoolsKit.Subject();
-/**
- * Done emitter for live background execution completion.
- * Emits when live background tasks complete (Live.background).
- */
-const doneLiveSubject = new functoolsKit.Subject();
-/**
- * Done emitter for backtest background execution completion.
- * Emits when backtest background tasks complete (Backtest.background).
- */
-const doneBacktestSubject = new functoolsKit.Subject();
-/**
- * Done emitter for walker background execution completion.
- * Emits when walker background tasks complete (Walker.background).
- */
-const doneWalkerSubject = new functoolsKit.Subject();
-/**
- * Progress emitter for backtest execution progress.
- * Emits progress updates during backtest execution.
- */
-const progressBacktestEmitter = new functoolsKit.Subject();
-/**
- * Progress emitter for walker execution progress.
- * Emits progress updates during walker execution.
- */
-const progressWalkerEmitter = new functoolsKit.Subject();
-/**
- * Progress emitter for optimizer execution progress.
- * Emits progress updates during optimizer execution.
- */
-const progressOptimizerEmitter = new functoolsKit.Subject();
-/**
- * Performance emitter for execution metrics.
- * Emits performance metrics for profiling and bottleneck detection.
- */
-const performanceEmitter = new functoolsKit.Subject();
-/**
- * Walker emitter for strategy comparison progress.
- * Emits progress updates during walker execution (each strategy completion).
- */
-const walkerEmitter = new functoolsKit.Subject();
-/**
- * Walker complete emitter for strategy comparison completion.
- * Emits when all strategies have been tested and final results are available.
- */
-const walkerCompleteSubject = new functoolsKit.Subject();
-/**
- * Walker stop emitter for walker cancellation events.
- * Emits when a walker comparison is stopped/cancelled.
- *
- * Includes walkerName to support multiple walkers running on the same symbol.
- */
-const walkerStopSubject = new functoolsKit.Subject();
-/**
- * Validation emitter for risk validation errors.
- * Emits when risk validation functions throw errors during signal checking.
- */
-const validationSubject = new functoolsKit.Subject();
-/**
- * Partial profit emitter for profit level milestones.
- * Emits when a signal reaches a profit level (10%, 20%, 30%, etc).
- */
-const partialProfitSubject = new functoolsKit.Subject();
-/**
- * Partial loss emitter for loss level milestones.
- * Emits when a signal reaches a loss level (10%, 20%, 30%, etc).
- */
-const partialLossSubject = new functoolsKit.Subject();
-/**
- * Risk rejection emitter for risk management violations.
- * Emits ONLY when a signal is rejected due to risk validation failure.
- * Does not emit for allowed signals (prevents spam).
- */
-const riskSubject = new functoolsKit.Subject();
-/**
- * Ping emitter for scheduled signal monitoring events.
- * Emits every minute when a scheduled signal is being monitored (waiting for activation).
- * Allows users to track scheduled signal lifecycle and implement custom cancellation logic.
- */
-const pingSubject = new functoolsKit.Subject();
-
-var emitters = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    doneBacktestSubject: doneBacktestSubject,
-    doneLiveSubject: doneLiveSubject,
-    doneWalkerSubject: doneWalkerSubject,
-    errorEmitter: errorEmitter,
-    exitEmitter: exitEmitter,
-    partialLossSubject: partialLossSubject,
-    partialProfitSubject: partialProfitSubject,
-    performanceEmitter: performanceEmitter,
-    pingSubject: pingSubject,
-    progressBacktestEmitter: progressBacktestEmitter,
-    progressOptimizerEmitter: progressOptimizerEmitter,
-    progressWalkerEmitter: progressWalkerEmitter,
-    riskSubject: riskSubject,
-    signalBacktestEmitter: signalBacktestEmitter,
-    signalEmitter: signalEmitter,
-    signalLiveEmitter: signalLiveEmitter,
-    validationSubject: validationSubject,
-    walkerCompleteSubject: walkerCompleteSubject,
-    walkerEmitter: walkerEmitter,
-    walkerStopSubject: walkerStopSubject
-});
-
-/**
- * Converts markdown content to plain text with minimal formatting
- * @param content - Markdown string to convert
- * @returns Plain text representation
- */
-const toPlainString = (content) => {
-    if (!content) {
-        return "";
+const TO_PUBLIC_SIGNAL = (signal) => {
+    if (signal._trailingPriceStopLoss !== undefined) {
+        return {
+            ...signal,
+            priceStopLoss: signal._trailingPriceStopLoss,
+            originalPriceStopLoss: signal.priceStopLoss,
+        };
     }
-    let text = content;
-    // Remove code blocks
-    text = text.replace(/```[\s\S]*?```/g, "");
-    text = text.replace(/`([^`]+)`/g, "$1");
-    // Remove images
-    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1");
-    // Convert links to text only (keep link text, remove URL)
-    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
-    // Remove headers (convert to plain text)
-    text = text.replace(/^#{1,6}\s+(.+)$/gm, "$1");
-    // Remove bold and italic markers
-    text = text.replace(/\*\*\*(.+?)\*\*\*/g, "$1");
-    text = text.replace(/\*\*(.+?)\*\*/g, "$1");
-    text = text.replace(/\*(.+?)\*/g, "$1");
-    text = text.replace(/___(.+?)___/g, "$1");
-    text = text.replace(/__(.+?)__/g, "$1");
-    text = text.replace(/_(.+?)_/g, "$1");
-    // Remove strikethrough
-    text = text.replace(/~~(.+?)~~/g, "$1");
-    // Convert lists to plain text with bullets
-    text = text.replace(/^\s*[-*+]\s+/gm, "• ");
-    text = text.replace(/^\s*\d+\.\s+/gm, "• ");
-    // Remove blockquotes
-    text = text.replace(/^\s*>\s+/gm, "");
-    // Remove horizontal rules
-    text = text.replace(/^(\*{3,}|-{3,}|_{3,})$/gm, "");
-    // Remove HTML tags
-    text = text.replace(/<[^>]+>/g, "");
-    // Remove excessive whitespace and normalize line breaks
-    text = text.replace(/\n[\s\n]*\n/g, "\n");
-    text = text.replace(/[ \t]+/g, " ");
-    // Remove all newline characters
-    text = text.replace(/\n/g, " ");
-    // Remove excessive spaces after newline removal
-    text = text.replace(/\s+/g, " ");
-    return text.trim();
-};
-
-const INTERVAL_MINUTES$3 = {
-    "1m": 1,
-    "3m": 3,
-    "5m": 5,
-    "15m": 15,
-    "30m": 30,
-    "1h": 60,
+    return {
+        ...signal,
+        originalPriceStopLoss: signal.priceStopLoss,
+    };
 };
-const TIMEOUT_SYMBOL = Symbol('timeout');
 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) {
@@ -2090,15 +2298,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
     if (self._isStopped) {
         return null;
     }
-    if (await functoolsKit.not(self.params.risk.checkSignal({
-        pendingSignal: signal,
-        symbol: self.params.execution.context.symbol,
-        strategyName: self.params.method.context.strategyName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-        currentPrice,
-        timestamp: currentTime,
-    }))) {
+    if (await functoolsKit.not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest))) {
         return null;
     }
     // Если priceOpen указан - проверяем нужно ли ждать активации или открыть сразу
@@ -2207,10 +2407,9 @@ const WAIT_FOR_INIT_FN$2 = async (self) => {
         }
         self._pendingSignal = pendingSignal;
         // Call onActive callback for restored signal
-        if (self.params.callbacks?.onActive) {
-            const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
-            self.params.callbacks.onActive(self.params.execution.context.symbol, pendingSignal, currentPrice, self.params.execution.context.backtest);
-        }
+        const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
+        const currentTime = self.params.execution.context.when.getTime();
+        await CALL_ACTIVE_CALLBACKS_FN(self, self.params.execution.context.symbol, pendingSignal, currentPrice, currentTime, self.params.execution.context.backtest);
     }
     // Restore scheduled signal
     const scheduledSignal = await PersistScheduleAdapter.readScheduleData(self.params.execution.context.symbol, self.params.strategyName);
@@ -2223,10 +2422,174 @@ const WAIT_FOR_INIT_FN$2 = async (self) => {
         }
         self._scheduledSignal = scheduledSignal;
         // Call onSchedule callback for restored scheduled signal
-        if (self.params.callbacks?.onSchedule) {
-            const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
-            self.params.callbacks.onSchedule(self.params.execution.context.symbol, scheduledSignal, currentPrice, self.params.execution.context.backtest);
+        const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
+        const currentTime = self.params.execution.context.when.getTime();
+        await CALL_SCHEDULE_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduledSignal, currentPrice, currentTime, self.params.execution.context.backtest);
+    }
+};
+const PARTIAL_PROFIT_FN = (self, signal, percentToClose, currentPrice) => {
+    // Initialize partial array if not present
+    if (!signal._partial)
+        signal._partial = [];
+    // Calculate current totals (computed values)
+    const tpClosed = signal._partial
+        .filter((p) => p.type === "profit")
+        .reduce((sum, p) => sum + p.percent, 0);
+    const slClosed = signal._partial
+        .filter((p) => p.type === "loss")
+        .reduce((sum, p) => sum + p.percent, 0);
+    const totalClosed = tpClosed + slClosed;
+    // Check if would exceed 100% total closed
+    const newTotalClosed = totalClosed + percentToClose;
+    if (newTotalClosed > 100) {
+        self.params.logger.warn("PARTIAL_PROFIT_FN: would exceed 100% closed, skipping", {
+            signalId: signal.id,
+            currentTotalClosed: totalClosed,
+            percentToClose,
+            newTotalClosed,
+        });
+        return;
+    }
+    // Add new partial close entry
+    signal._partial.push({
+        type: "profit",
+        percent: percentToClose,
+        price: currentPrice,
+    });
+    self.params.logger.info("PARTIAL_PROFIT_FN executed", {
+        signalId: signal.id,
+        percentClosed: percentToClose,
+        totalClosed: newTotalClosed,
+        currentPrice,
+        tpClosed: tpClosed + percentToClose,
+    });
+};
+const PARTIAL_LOSS_FN = (self, signal, percentToClose, currentPrice) => {
+    // Initialize partial array if not present
+    if (!signal._partial)
+        signal._partial = [];
+    // Calculate current totals (computed values)
+    const tpClosed = signal._partial
+        .filter((p) => p.type === "profit")
+        .reduce((sum, p) => sum + p.percent, 0);
+    const slClosed = signal._partial
+        .filter((p) => p.type === "loss")
+        .reduce((sum, p) => sum + p.percent, 0);
+    const totalClosed = tpClosed + slClosed;
+    // Check if would exceed 100% total closed
+    const newTotalClosed = totalClosed + percentToClose;
+    if (newTotalClosed > 100) {
+        self.params.logger.warn("PARTIAL_LOSS_FN: would exceed 100% closed, skipping", {
+            signalId: signal.id,
+            currentTotalClosed: totalClosed,
+            percentToClose,
+            newTotalClosed,
+        });
+        return;
+    }
+    // Add new partial close entry
+    signal._partial.push({
+        type: "loss",
+        percent: percentToClose,
+        price: currentPrice,
+    });
+    self.params.logger.warn("PARTIAL_LOSS_FN executed", {
+        signalId: signal.id,
+        percentClosed: percentToClose,
+        totalClosed: newTotalClosed,
+        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) => {
@@ -2244,12 +2607,10 @@ const CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN = async (self, scheduled, currentPrice)
         maxMinutes: GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES,
     });
     await self.setScheduledSignal(null);
-    if (self.params.callbacks?.onCancel) {
-        self.params.callbacks.onCancel(self.params.execution.context.symbol, scheduled, currentPrice, self.params.execution.context.backtest);
-    }
+    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,
@@ -2259,9 +2620,7 @@ const CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN = async (self, scheduled, currentPrice)
         backtest: self.params.execution.context.backtest,
         reason: "timeout",
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const CHECK_SCHEDULED_SIGNAL_PRICE_ACTIVATION_FN = (scheduled, currentPrice) => {
@@ -2302,14 +2661,13 @@ const CANCEL_SCHEDULED_SIGNAL_BY_STOPLOSS_FN = async (self, scheduled, currentPr
         priceStopLoss: scheduled.priceStopLoss,
     });
     await self.setScheduledSignal(null);
-    if (self.params.callbacks?.onCancel) {
-        self.params.callbacks.onCancel(self.params.execution.context.symbol, scheduled, currentPrice, self.params.execution.context.backtest);
-    }
+    const currentTime = self.params.execution.context.when.getTime();
+    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: self.params.execution.context.when.getTime(),
+        closeTimestamp: currentTime,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         frameName: self.params.method.context.frameName,
@@ -2317,9 +2675,7 @@ const CANCEL_SCHEDULED_SIGNAL_BY_STOPLOSS_FN = async (self, scheduled, currentPr
         backtest: self.params.execution.context.backtest,
         reason: "price_reject",
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp) => {
@@ -2346,15 +2702,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
         scheduledAt: scheduled.scheduledAt,
         pendingAt: activationTime,
     });
-    if (await functoolsKit.not(self.params.risk.checkSignal({
-        symbol: self.params.execution.context.symbol,
-        pendingSignal: scheduled,
-        strategyName: self.params.method.context.strategyName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-        currentPrice: scheduled.priceOpen,
-        timestamp: activationTime,
-    }))) {
+    if (await functoolsKit.not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, scheduled, scheduled.priceOpen, activationTime, self.params.execution.context.backtest))) {
         self.params.logger.info("ClientStrategy scheduled signal rejected by risk", {
             symbol: self.params.execution.context.symbol,
             signalId: scheduled.id,
@@ -2370,18 +2718,11 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
         _isScheduled: false,
     };
     await self.setPendingSignal(activatedSignal);
-    await self.params.risk.addSignal(self.params.execution.context.symbol, {
-        strategyName: self.params.method.context.strategyName,
-        riskName: self.params.riskName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-    });
-    if (self.params.callbacks?.onOpen) {
-        self.params.callbacks.onOpen(self.params.execution.context.symbol, self._pendingSignal, self._pendingSignal.priceOpen, self.params.execution.context.backtest);
-    }
+    await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, activationTime, self.params.execution.context.backtest);
+    await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, self._pendingSignal, self._pendingSignal.priceOpen, activationTime, self.params.execution.context.backtest);
     const result = {
         action: "opened",
-        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,
@@ -2389,18 +2730,23 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
         currentPrice: self._pendingSignal.priceOpen,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, activationTime, self.params.execution.context.backtest);
     return result;
 };
-const CALL_PING_CALLBACKS_FN = functoolsKit.trycatch(async (self, scheduled, timestamp) => {
-    // 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);
-    // 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);
-    }
+const CALL_PING_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, scheduled, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        const publicSignal = TO_PUBLIC_SIGNAL(scheduled);
+        // Call system onPing callback first (emits to pingSubject)
+        await self.params.onPing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, 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, publicSignal, new Date(timestamp), self.params.execution.context.backtest);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
 }, {
     fallback: (error) => {
         const message = "ClientStrategy CALL_PING_CALLBACKS_FN thrown";
@@ -2413,11 +2759,319 @@ const CALL_PING_CALLBACKS_FN = functoolsKit.trycatch(async (self, scheduled, tim
         errorEmitter.next(error);
     },
 });
+const CALL_ACTIVE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (self.params.callbacks?.onActive) {
+            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),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_ACTIVE_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_SCHEDULE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (self.params.callbacks?.onSchedule) {
+            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),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_SCHEDULE_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_CANCEL_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (self.params.callbacks?.onCancel) {
+            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),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_CANCEL_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_OPEN_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, priceOpen, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (self.params.callbacks?.onOpen) {
+            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),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_OPEN_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_CLOSE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (self.params.callbacks?.onClose) {
+            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),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_CLOSE_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_TICK_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, result, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (self.params.callbacks?.onTick) {
+            await self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_TICK_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_IDLE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, currentPrice, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (self.params.callbacks?.onIdle) {
+            await self.params.callbacks.onIdle(self.params.execution.context.symbol, currentPrice, self.params.execution.context.backtest);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_IDLE_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_RISK_ADD_SIGNAL_FN = functoolsKit.trycatch(async (self, symbol, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        await self.params.risk.addSignal(symbol, {
+            strategyName: self.params.method.context.strategyName,
+            riskName: self.params.riskName,
+            exchangeName: self.params.method.context.exchangeName,
+            frameName: self.params.method.context.frameName,
+        });
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_RISK_ADD_SIGNAL_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_RISK_REMOVE_SIGNAL_FN = functoolsKit.trycatch(async (self, symbol, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        await self.params.risk.removeSignal(symbol, {
+            strategyName: self.params.method.context.strategyName,
+            riskName: self.params.riskName,
+            exchangeName: self.params.method.context.exchangeName,
+            frameName: self.params.method.context.frameName,
+        });
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_RISK_REMOVE_SIGNAL_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_PARTIAL_CLEAR_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        const publicSignal = TO_PUBLIC_SIGNAL(signal);
+        await self.params.partial.clear(symbol, publicSignal, currentPrice, backtest);
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_PARTIAL_CLEAR_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_RISK_CHECK_SIGNAL_FN = functoolsKit.trycatch(async (self, symbol, pendingSignal, currentPrice, timestamp, backtest) => {
+    return await ExecutionContextService.runInContext(async () => {
+        return await self.params.risk.checkSignal({
+            pendingSignal,
+            symbol: symbol,
+            strategyName: self.params.method.context.strategyName,
+            exchangeName: self.params.method.context.exchangeName,
+            frameName: self.params.method.context.frameName,
+            currentPrice,
+            timestamp,
+        });
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    defaultValue: false,
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_RISK_CHECK_SIGNAL_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_PARTIAL_PROFIT_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, percentTp, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        const publicSignal = TO_PUBLIC_SIGNAL(signal);
+        await self.params.partial.profit(symbol, publicSignal, currentPrice, percentTp, backtest, new Date(timestamp));
+        if (self.params.callbacks?.onPartialProfit) {
+            await self.params.callbacks.onPartialProfit(symbol, publicSignal, currentPrice, percentTp, backtest);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_PARTIAL_PROFIT_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_PARTIAL_LOSS_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, percentSl, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        const publicSignal = TO_PUBLIC_SIGNAL(signal);
+        await self.params.partial.loss(symbol, publicSignal, currentPrice, percentSl, backtest, new Date(timestamp));
+        if (self.params.callbacks?.onPartialLoss) {
+            await self.params.callbacks.onPartialLoss(symbol, publicSignal, currentPrice, percentSl, backtest);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_PARTIAL_LOSS_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 const RETURN_SCHEDULED_SIGNAL_ACTIVE_FN = async (self, scheduled, currentPrice) => {
-    await CALL_PING_CALLBACKS_FN(self, scheduled, self.params.execution.context.when.getTime());
+    const currentTime = self.params.execution.context.when.getTime();
+    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,
@@ -2427,13 +3081,12 @@ const RETURN_SCHEDULED_SIGNAL_ACTIVE_FN = async (self, scheduled, currentPrice)
         percentSl: 0,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const OPEN_NEW_SCHEDULED_SIGNAL_FN = async (self, signal) => {
     const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
+    const currentTime = self.params.execution.context.when.getTime();
     self.params.logger.info("ClientStrategy scheduled signal created", {
         symbol: self.params.execution.context.symbol,
         signalId: signal.id,
@@ -2441,12 +3094,10 @@ const OPEN_NEW_SCHEDULED_SIGNAL_FN = async (self, signal) => {
         priceOpen: signal.priceOpen,
         currentPrice: currentPrice,
     });
-    if (self.params.callbacks?.onSchedule) {
-        self.params.callbacks.onSchedule(self.params.execution.context.symbol, signal, currentPrice, self.params.execution.context.backtest);
-    }
+    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,
@@ -2454,35 +3105,19 @@ const OPEN_NEW_SCHEDULED_SIGNAL_FN = async (self, signal) => {
         currentPrice: currentPrice,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const OPEN_NEW_PENDING_SIGNAL_FN = async (self, signal) => {
-    if (await functoolsKit.not(self.params.risk.checkSignal({
-        pendingSignal: signal,
-        symbol: self.params.execution.context.symbol,
-        strategyName: self.params.method.context.strategyName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-        currentPrice: signal.priceOpen,
-        timestamp: self.params.execution.context.when.getTime(),
-    }))) {
+    const currentTime = self.params.execution.context.when.getTime();
+    if (await functoolsKit.not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, signal, signal.priceOpen, currentTime, self.params.execution.context.backtest))) {
         return null;
     }
-    await self.params.risk.addSignal(self.params.execution.context.symbol, {
-        strategyName: self.params.method.context.strategyName,
-        riskName: self.params.riskName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-    });
-    if (self.params.callbacks?.onOpen) {
-        self.params.callbacks.onOpen(self.params.execution.context.symbol, signal, signal.priceOpen, self.params.execution.context.backtest);
-    }
+    await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, currentTime, self.params.execution.context.backtest);
+    await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, signal.priceOpen, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "opened",
-        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,
@@ -2490,9 +3125,7 @@ const OPEN_NEW_PENDING_SIGNAL_FN = async (self, signal) => {
         currentPrice: signal.priceOpen,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const CHECK_PENDING_SIGNAL_COMPLETION_FN = async (self, signal, averagePrice) => {
@@ -2513,19 +3146,21 @@ 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;
 };
 const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason) => {
     const pnl = toProfitLossDto(signal, currentPrice);
+    const currentTime = self.params.execution.context.when.getTime();
     self.params.logger.info(`ClientStrategy signal ${closeReason}`, {
         symbol: self.params.execution.context.symbol,
         signalId: signal.id,
@@ -2533,24 +3168,17 @@ const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason)
         priceClose: currentPrice,
         pnlPercentage: pnl.pnlPercentage,
     });
-    if (self.params.callbacks?.onClose) {
-        self.params.callbacks.onClose(self.params.execution.context.symbol, signal, currentPrice, self.params.execution.context.backtest);
-    }
+    await CALL_CLOSE_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
     // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
-    await self.params.partial.clear(self.params.execution.context.symbol, signal, currentPrice, self.params.execution.context.backtest);
-    await self.params.risk.removeSignal(self.params.execution.context.symbol, {
-        strategyName: self.params.method.context.strategyName,
-        riskName: self.params.riskName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-    });
+    await CALL_PARTIAL_CLEAR_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest);
+    await CALL_RISK_REMOVE_SIGNAL_FN(self, self.params.execution.context.symbol, currentTime, self.params.execution.context.backtest);
     await self.setPendingSignal(null);
     const result = {
         action: "closed",
-        signal: signal,
+        signal: TO_PUBLIC_SIGNAL(signal),
         currentPrice: currentPrice,
         closeReason: closeReason,
-        closeTimestamp: self.params.execution.context.when.getTime(),
+        closeTimestamp: currentTime,
         pnl: pnl,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
@@ -2558,14 +3186,13 @@ const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason)
         symbol: self.params.execution.context.symbol,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
     let percentTp = 0;
     let percentSl = 0;
+    const currentTime = self.params.execution.context.when.getTime();
     // Calculate percentage of path to TP/SL for partial fill/loss callbacks
     {
         if (signal.position === "long") {
@@ -2576,20 +3203,15 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
                 const tpDistance = signal.priceTakeProfit - signal.priceOpen;
                 const progressPercent = (currentDistance / tpDistance) * 100;
                 percentTp = Math.min(progressPercent, 100);
-                await self.params.partial.profit(self.params.execution.context.symbol, signal, currentPrice, percentTp, self.params.execution.context.backtest, self.params.execution.context.when);
-                if (self.params.callbacks?.onPartialProfit) {
-                    self.params.callbacks.onPartialProfit(self.params.execution.context.symbol, signal, currentPrice, percentTp, self.params.execution.context.backtest);
-                }
+                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 self.params.partial.loss(self.params.execution.context.symbol, signal, currentPrice, percentSl, self.params.execution.context.backtest, self.params.execution.context.when);
-                if (self.params.callbacks?.onPartialLoss) {
-                    self.params.callbacks.onPartialLoss(self.params.execution.context.symbol, signal, currentPrice, percentSl, self.params.execution.context.backtest);
-                }
+                await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentSl, currentTime, self.params.execution.context.backtest);
             }
         }
         else if (signal.position === "short") {
@@ -2600,26 +3222,21 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
                 const tpDistance = signal.priceOpen - signal.priceTakeProfit;
                 const progressPercent = (currentDistance / tpDistance) * 100;
                 percentTp = Math.min(progressPercent, 100);
-                await self.params.partial.profit(self.params.execution.context.symbol, signal, currentPrice, percentTp, self.params.execution.context.backtest, self.params.execution.context.when);
-                if (self.params.callbacks?.onPartialProfit) {
-                    self.params.callbacks.onPartialProfit(self.params.execution.context.symbol, signal, currentPrice, percentTp, self.params.execution.context.backtest);
-                }
+                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 self.params.partial.loss(self.params.execution.context.symbol, signal, currentPrice, percentSl, self.params.execution.context.backtest, self.params.execution.context.when);
-                if (self.params.callbacks?.onPartialLoss) {
-                    self.params.callbacks.onPartialLoss(self.params.execution.context.symbol, signal, currentPrice, percentSl, self.params.execution.context.backtest);
-                }
+                await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentSl, currentTime, self.params.execution.context.backtest);
             }
         }
     }
     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,
@@ -2629,15 +3246,12 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
         percentSl,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const RETURN_IDLE_FN = async (self, currentPrice) => {
-    if (self.params.callbacks?.onIdle) {
-        self.params.callbacks.onIdle(self.params.execution.context.symbol, currentPrice, self.params.execution.context.backtest);
-    }
+    const currentTime = self.params.execution.context.when.getTime();
+    await CALL_IDLE_CALLBACKS_FN(self, self.params.execution.context.symbol, currentPrice, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "idle",
         signal: null,
@@ -2648,9 +3262,7 @@ const RETURN_IDLE_FN = async (self, currentPrice) => {
         currentPrice: currentPrice,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePrice, closeTimestamp, reason) => {
@@ -2663,12 +3275,10 @@ const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePr
         reason,
     });
     await self.setScheduledSignal(null);
-    if (self.params.callbacks?.onCancel) {
-        self.params.callbacks.onCancel(self.params.execution.context.symbol, scheduled, averagePrice, self.params.execution.context.backtest);
-    }
+    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,
@@ -2678,9 +3288,7 @@ const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePr
         backtest: self.params.execution.context.backtest,
         reason,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
     return result;
 };
 const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activationTimestamp) => {
@@ -2704,15 +3312,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
         scheduledAt: scheduled.scheduledAt,
         pendingAt: activationTime,
     });
-    if (await functoolsKit.not(self.params.risk.checkSignal({
-        pendingSignal: scheduled,
-        symbol: self.params.execution.context.symbol,
-        strategyName: self.params.method.context.strategyName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-        currentPrice: scheduled.priceOpen,
-        timestamp: activationTime,
-    }))) {
+    if (await functoolsKit.not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, scheduled, scheduled.priceOpen, activationTime, self.params.execution.context.backtest))) {
         self.params.logger.info("ClientStrategy backtest scheduled signal rejected by risk", {
             symbol: self.params.execution.context.symbol,
             signalId: scheduled.id,
@@ -2728,15 +3328,8 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
         _isScheduled: false,
     };
     await self.setPendingSignal(activatedSignal);
-    await self.params.risk.addSignal(self.params.execution.context.symbol, {
-        strategyName: self.params.method.context.strategyName,
-        riskName: self.params.riskName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-    });
-    if (self.params.callbacks?.onOpen) {
-        self.params.callbacks.onOpen(self.params.execution.context.symbol, activatedSignal, activatedSignal.priceOpen, self.params.execution.context.backtest);
-    }
+    await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, activationTime, self.params.execution.context.backtest);
+    await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, activatedSignal, activatedSignal.priceOpen, activationTime, self.params.execution.context.backtest);
     return true;
 };
 const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, closeReason, closeTimestamp) => {
@@ -2755,21 +3348,14 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
     if (closeReason === "time_expired" && pnl.pnlPercentage < 0) {
         self.params.logger.warn(`ClientStrategy backtest: Signal closed with loss (time_expired), PNL: ${pnl.pnlPercentage.toFixed(2)}%`);
     }
-    if (self.params.callbacks?.onClose) {
-        self.params.callbacks.onClose(self.params.execution.context.symbol, signal, averagePrice, self.params.execution.context.backtest);
-    }
+    await CALL_CLOSE_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
     // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
-    await self.params.partial.clear(self.params.execution.context.symbol, signal, averagePrice, self.params.execution.context.backtest);
-    await self.params.risk.removeSignal(self.params.execution.context.symbol, {
-        strategyName: self.params.method.context.strategyName,
-        riskName: self.params.riskName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-    });
+    await CALL_PARTIAL_CLEAR_FN(self, self.params.execution.context.symbol, signal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
+    await CALL_RISK_REMOVE_SIGNAL_FN(self, self.params.execution.context.symbol, closeTimestamp, self.params.execution.context.backtest);
     await self.setPendingSignal(null);
     const result = {
         action: "closed",
-        signal: signal,
+        signal: TO_PUBLIC_SIGNAL(signal),
         currentPrice: averagePrice,
         closeReason: closeReason,
         closeTimestamp: closeTimestamp,
@@ -2780,9 +3366,7 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
         symbol: self.params.execution.context.symbol,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
     return result;
 };
 const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) => {
@@ -2857,7 +3441,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                 result: null,
             };
         }
-        await CALL_PING_CALLBACKS_FN(self, scheduled, candle.timestamp);
+        await CALL_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, candle.timestamp, true);
     }
     return {
         activated: false,
@@ -2895,13 +3479,15 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         }
         // Check TP/SL only if not expired
         // КРИТИЧНО: используем candle.high/low для точной проверки достижения TP/SL
+        // КРИТИЧНО: используем trailing SL если установлен
+        const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
         if (!shouldClose && signal.position === "long") {
             // Для LONG: TP срабатывает если high >= TP, SL если low <= SL
             if (currentCandle.high >= signal.priceTakeProfit) {
                 shouldClose = true;
                 closeReason = "take_profit";
             }
-            else if (currentCandle.low <= signal.priceStopLoss) {
+            else if (currentCandle.low <= effectiveStopLoss) {
                 shouldClose = true;
                 closeReason = "stop_loss";
             }
@@ -2912,7 +3498,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                 shouldClose = true;
                 closeReason = "take_profit";
             }
-            else if (currentCandle.high >= signal.priceStopLoss) {
+            else if (currentCandle.high >= effectiveStopLoss) {
                 shouldClose = true;
                 closeReason = "stop_loss";
             }
@@ -2924,7 +3510,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                 closePrice = signal.priceTakeProfit;
             }
             else if (closeReason === "stop_loss") {
-                closePrice = signal.priceStopLoss;
+                closePrice = effectiveStopLoss; // Используем trailing SL если установлен
             }
             return await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(self, signal, closePrice, closeReason, currentCandleTimestamp);
         }
@@ -2938,19 +3524,14 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     // Moving towards TP
                     const tpDistance = signal.priceTakeProfit - signal.priceOpen;
                     const progressPercent = (currentDistance / tpDistance) * 100;
-                    await self.params.partial.profit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, new Date(currentCandleTimestamp));
-                    if (self.params.callbacks?.onPartialProfit) {
-                        self.params.callbacks.onPartialProfit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest);
-                    }
+                    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 self.params.partial.loss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, new Date(currentCandleTimestamp));
-                    if (self.params.callbacks?.onPartialLoss) {
-                        self.params.callbacks.onPartialLoss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest);
-                    }
+                    await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
             }
             else if (signal.position === "short") {
@@ -2960,19 +3541,14 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     // Moving towards TP
                     const tpDistance = signal.priceOpen - signal.priceTakeProfit;
                     const progressPercent = (currentDistance / tpDistance) * 100;
-                    await self.params.partial.profit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, new Date(currentCandleTimestamp));
-                    if (self.params.callbacks?.onPartialProfit) {
-                        self.params.callbacks.onPartialProfit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest);
-                    }
+                    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 self.params.partial.loss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, new Date(currentCandleTimestamp));
-                    if (self.params.callbacks?.onPartialLoss) {
-                        self.params.callbacks.onPartialLoss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest);
-                    }
+                    await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
             }
         }
@@ -3042,7 +3618,8 @@ class ClientStrategy {
         // КРИТИЧНО: Всегда вызываем коллбек onWrite для тестирования persist storage
         // даже в backtest режиме, чтобы тесты могли перехватывать вызовы через mock adapter
         if (this.params.callbacks?.onWrite) {
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, this._pendingSignal, this.params.execution.context.backtest);
+            const publicSignal = this._pendingSignal ? TO_PUBLIC_SIGNAL(this._pendingSignal) : null;
+            this.params.callbacks.onWrite(this.params.execution.context.symbol, publicSignal, this.params.execution.context.backtest);
         }
         if (this.params.execution.context.backtest) {
             return;
@@ -3077,7 +3654,7 @@ class ClientStrategy {
         this.params.logger.debug("ClientStrategy getPendingSignal", {
             symbol,
         });
-        return this._pendingSignal;
+        return this._pendingSignal ? TO_PUBLIC_SIGNAL(this._pendingSignal) : null;
     }
     /**
      * Retrieves the current scheduled signal.
@@ -3088,7 +3665,7 @@ class ClientStrategy {
         this.params.logger.debug("ClientStrategy getScheduledSignal", {
             symbol,
         });
-        return this._scheduledSignal;
+        return this._scheduledSignal ? TO_PUBLIC_SIGNAL(this._scheduledSignal) : null;
     }
     /**
      * Returns the stopped state of the strategy.
@@ -3158,12 +3735,10 @@ class ClientStrategy {
                 signalId: cancelledSignal.id,
             });
             // Call onCancel callback
-            if (this.params.callbacks?.onCancel) {
-                this.params.callbacks.onCancel(this.params.execution.context.symbol, cancelledSignal, currentPrice, this.params.execution.context.backtest);
-            }
+            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,
@@ -3272,14 +3847,13 @@ class ClientStrategy {
             const currentPrice = await this.params.exchange.getAveragePrice(symbol);
             const cancelledSignal = this._cancelledSignal;
             this._cancelledSignal = null; // Clear after using
-            if (this.params.callbacks?.onCancel) {
-                this.params.callbacks.onCancel(this.params.execution.context.symbol, cancelledSignal, currentPrice, this.params.execution.context.backtest);
-            }
+            const closeTimestamp = this.params.execution.context.when.getTime();
+            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: this.params.execution.context.when.getTime(),
+                closeTimestamp: closeTimestamp,
                 strategyName: this.params.method.context.strategyName,
                 exchangeName: this.params.method.context.exchangeName,
                 frameName: this.params.method.context.frameName,
@@ -3339,7 +3913,7 @@ class ClientStrategy {
                     // but this is correct behavior if someone calls backtest() with partial data
                     const result = {
                         action: "active",
-                        signal: scheduled,
+                        signal: TO_PUBLIC_SIGNAL(scheduled),
                         currentPrice: lastPrice,
                         percentSl: 0,
                         percentTp: 0,
@@ -3458,6 +4032,273 @@ class ClientStrategy {
         }
         await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName);
     }
+    /**
+     * Executes partial close at profit level (moving toward TP).
+     *
+     * Closes a percentage of the pending position at the current price, recording it as a "profit" type partial.
+     * The partial close is tracked in `_partial` array for weighted PNL calculation when position fully closes.
+     *
+     * Behavior:
+     * - Adds entry to signal's `_partial` array with type "profit"
+     * - Validates percentToClose is in range (0, 100]
+     * - Silently skips if total closed would exceed 100%
+     * - Persists updated signal state (backtest and live modes)
+     * - Calls onWrite callback for persistence testing
+     *
+     * Validation:
+     * - Throws if no pending signal exists
+     * - Throws if percentToClose is not a finite number
+     * - Throws if percentToClose <= 0 or > 100
+     * - Throws if currentPrice is not a positive finite number
+     * - Throws if currentPrice is not moving toward TP:
+     *   - LONG: currentPrice must be > priceOpen
+     *   - SHORT: currentPrice must be < priceOpen
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentToClose - Percentage of position to close (0-100, absolute value)
+     * @param currentPrice - Current market price for this partial close (must be in profit direction)
+     * @param backtest - Whether running in backtest mode (controls persistence)
+     * @returns Promise that resolves when state is updated and persisted
+     *
+     * @example
+     * ```typescript
+     * // Close 30% of position at profit (moving toward TP)
+     * await strategy.partialProfit("BTCUSDT", 30, 45000, false);
+     *
+     * // Later close another 20%
+     * await strategy.partialProfit("BTCUSDT", 20, 46000, false);
+     *
+     * // Final close will calculate weighted PNL from all partials
+     * ```
+     */
+    async partialProfit(symbol, percentToClose, currentPrice, backtest) {
+        this.params.logger.debug("ClientStrategy partialProfit", {
+            symbol,
+            percentToClose,
+            currentPrice,
+            hasPendingSignal: this._pendingSignal !== null,
+        });
+        // Validation: must have pending signal
+        if (!this._pendingSignal) {
+            throw new Error(`ClientStrategy partialProfit: No pending signal exists for symbol=${symbol}`);
+        }
+        // Validation: percentToClose must be valid
+        if (typeof percentToClose !== "number" || !isFinite(percentToClose)) {
+            throw new Error(`ClientStrategy partialProfit: percentToClose must be a finite number, got ${percentToClose} (${typeof percentToClose})`);
+        }
+        if (percentToClose <= 0) {
+            throw new Error(`ClientStrategy partialProfit: percentToClose must be > 0, got ${percentToClose}`);
+        }
+        if (percentToClose > 100) {
+            throw new Error(`ClientStrategy partialProfit: percentToClose must be <= 100, got ${percentToClose}`);
+        }
+        // Validation: currentPrice must be valid
+        if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0) {
+            throw new Error(`ClientStrategy partialProfit: currentPrice must be a positive finite number, got ${currentPrice}`);
+        }
+        // Validation: currentPrice must be moving toward TP (profit direction)
+        if (this._pendingSignal.position === "long") {
+            // For LONG: currentPrice must be higher than priceOpen (moving toward TP)
+            if (currentPrice <= this._pendingSignal.priceOpen) {
+                throw new Error(`ClientStrategy partialProfit: For LONG position, currentPrice (${currentPrice}) must be > priceOpen (${this._pendingSignal.priceOpen})`);
+            }
+        }
+        else {
+            // For SHORT: currentPrice must be lower than priceOpen (moving toward TP)
+            if (currentPrice >= this._pendingSignal.priceOpen) {
+                throw new Error(`ClientStrategy partialProfit: For SHORT position, currentPrice (${currentPrice}) must be < priceOpen (${this._pendingSignal.priceOpen})`);
+            }
+        }
+        // Execute partial close logic
+        PARTIAL_PROFIT_FN(this, this._pendingSignal, percentToClose, currentPrice);
+        // Persist updated signal state (inline setPendingSignal content)
+        // Note: this._pendingSignal already mutated by PARTIAL_PROFIT_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) {
+            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);
+        }
+    }
+    /**
+     * 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.
+     *
+     * Behavior:
+     * - Adds entry to signal's `_partial` array with type "loss"
+     * - Validates percentToClose is in range (0, 100]
+     * - Silently skips if total closed would exceed 100%
+     * - Persists updated signal state (backtest and live modes)
+     * - Calls onWrite callback for persistence testing
+     *
+     * Validation:
+     * - Throws if no pending signal exists
+     * - Throws if percentToClose is not a finite number
+     * - Throws if percentToClose <= 0 or > 100
+     * - Throws if currentPrice is not a positive finite number
+     * - Throws if currentPrice is not moving toward SL:
+     *   - LONG: currentPrice must be < priceOpen
+     *   - SHORT: currentPrice must be > priceOpen
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param percentToClose - Percentage of position to close (0-100, absolute value)
+     * @param currentPrice - Current market price for this partial close (must be in loss direction)
+     * @param backtest - Whether running in backtest mode (controls persistence)
+     * @returns Promise that resolves when state is updated and persisted
+     *
+     * @example
+     * ```typescript
+     * // Close 40% of position at loss (moving toward SL)
+     * await strategy.partialLoss("BTCUSDT", 40, 38000, false);
+     *
+     * // Later close another 30%
+     * await strategy.partialLoss("BTCUSDT", 30, 37000, false);
+     *
+     * // Final close will calculate weighted PNL from all partials
+     * ```
+     */
+    async partialLoss(symbol, percentToClose, currentPrice, backtest) {
+        this.params.logger.debug("ClientStrategy partialLoss", {
+            symbol,
+            percentToClose,
+            currentPrice,
+            hasPendingSignal: this._pendingSignal !== null,
+        });
+        // Validation: must have pending signal
+        if (!this._pendingSignal) {
+            throw new Error(`ClientStrategy partialLoss: No pending signal exists for symbol=${symbol}`);
+        }
+        // Validation: percentToClose must be valid
+        if (typeof percentToClose !== "number" || !isFinite(percentToClose)) {
+            throw new Error(`ClientStrategy partialLoss: percentToClose must be a finite number, got ${percentToClose} (${typeof percentToClose})`);
+        }
+        if (percentToClose <= 0) {
+            throw new Error(`ClientStrategy partialLoss: percentToClose must be > 0, got ${percentToClose}`);
+        }
+        if (percentToClose > 100) {
+            throw new Error(`ClientStrategy partialLoss: percentToClose must be <= 100, got ${percentToClose}`);
+        }
+        // Validation: currentPrice must be valid
+        if (typeof currentPrice !== "number" || !isFinite(currentPrice) || currentPrice <= 0) {
+            throw new Error(`ClientStrategy partialLoss: currentPrice must be a positive finite number, got ${currentPrice}`);
+        }
+        // Validation: currentPrice must be moving toward SL (loss direction)
+        if (this._pendingSignal.position === "long") {
+            // For LONG: currentPrice must be lower than priceOpen (moving toward SL)
+            if (currentPrice >= this._pendingSignal.priceOpen) {
+                throw new Error(`ClientStrategy partialLoss: For LONG position, currentPrice (${currentPrice}) must be < priceOpen (${this._pendingSignal.priceOpen})`);
+            }
+        }
+        else {
+            // For SHORT: currentPrice must be higher than priceOpen (moving toward SL)
+            if (currentPrice <= this._pendingSignal.priceOpen) {
+                throw new Error(`ClientStrategy partialLoss: For SHORT position, currentPrice (${currentPrice}) must be > priceOpen (${this._pendingSignal.priceOpen})`);
+            }
+        }
+        // Execute partial close logic
+        PARTIAL_LOSS_FN(this, this._pendingSignal, percentToClose, currentPrice);
+        // Persist updated signal state (inline setPendingSignal content)
+        // Note: this._pendingSignal already mutated by PARTIAL_LOSS_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) {
+            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);
+        }
+    }
 }
 
 const RISK_METHOD_NAME_GET_DATA = "RiskUtils.getData";
@@ -3859,6 +4700,7 @@ class StrategyConnectionService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.executionContextService = inject(TYPES.executionContextService);
+        this.methodContextService = inject(TYPES.methodContextService);
         this.strategySchemaService = inject(TYPES.strategySchemaService);
         this.riskConnectionService = inject(TYPES.riskConnectionService);
         this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
@@ -3882,7 +4724,7 @@ class StrategyConnectionService {
                 symbol,
                 interval,
                 execution: this.executionContextService,
-                method: { context: { strategyName, exchangeName, frameName } },
+                method: this.methodContextService,
                 logger: this.loggerService,
                 partial: this.partialConnectionService,
                 exchange: this.exchangeConnectionService,
@@ -4084,6 +4926,118 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             await strategy.cancel(symbol, backtest, cancelId);
         };
+        /**
+         * Executes partial close at profit level (moving toward TP).
+         *
+         * Closes a percentage of the pending position at the current price, recording it as a "profit" type partial.
+         * The partial close is tracked in `_partial` array for weighted PNL calculation when position fully closes.
+         *
+         * Delegates to ClientStrategy.partialProfit() 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 30% of position at profit
+         * await strategyConnectionService.partialProfit(
+         *   false,
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" },
+         *   30,
+         *   45000
+         * );
+         * ```
+         */
+        this.partialProfit = async (backtest, symbol, percentToClose, currentPrice, context) => {
+            this.loggerService.log("strategyConnectionService partialProfit", {
+                symbol,
+                context,
+                percentToClose,
+                currentPrice,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await strategy.partialProfit(symbol, percentToClose, currentPrice, backtest);
+        };
+        /**
+         * 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.
+         *
+         * 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.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
+         * @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 strategyConnectionService.trailingStop(
+         *   false,
+         *   "BTCUSDT",
+         *   -50,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+         * );
+         * ```
+         */
+        this.trailingStop = async (backtest, symbol, percentShift, context) => {
+            this.loggerService.log("strategyConnectionService trailingStop", {
+                symbol,
+                context,
+                percentShift,
+                backtest,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await strategy.trailingStop(symbol, percentShift, backtest);
+        };
     }
 }
 
@@ -4106,6 +5060,32 @@ const INTERVAL_MINUTES$2 = {
     "1d": 1440,
     "3d": 4320,
 };
+/**
+ * Wrapper to call onTimeframe callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param self - ClientFrame instance reference
+ * @param timeframe - Array of generated timestamp dates
+ * @param startDate - Start date of the backtest period
+ * @param endDate - Effective end date of the backtest period
+ * @param interval - Frame interval used for generation
+ */
+const CALL_TIMEFRAME_CALLBACKS_FN = functoolsKit.trycatch(async (self, timeframe, startDate, endDate, interval) => {
+    if (self.params.callbacks?.onTimeframe) {
+        await self.params.callbacks.onTimeframe(timeframe, startDate, endDate, interval);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientFrame CALL_TIMEFRAME_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Generates timeframe array from startDate to endDate with specified interval.
  * Uses prototype function pattern for memory efficiency.
@@ -4135,9 +5115,7 @@ const GET_TIMEFRAME_FN = async (symbol, self) => {
         timeframes.push(new Date(currentDate));
         currentDate = new Date(currentDate.getTime() + intervalMinutes * 60 * 1000);
     }
-    if (self.params.callbacks?.onTimeframe) {
-        self.params.callbacks.onTimeframe(timeframes, startDate, effectiveEndDate, interval);
-    }
+    await CALL_TIMEFRAME_CALLBACKS_FN(self, timeframes, startDate, effectiveEndDate, interval);
     return timeframes;
 };
 /**
@@ -4296,6 +5274,30 @@ const calculateATRBased = (params, schema) => {
     const stopDistance = atr * atrMultiplier;
     return riskAmount / stopDistance;
 };
+/**
+ * Wrapper to call onCalculate callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param self - ClientSizing instance reference
+ * @param quantity - Calculated position size
+ * @param params - Parameters used for size calculation
+ */
+const CALL_CALCULATE_CALLBACKS_FN = functoolsKit.trycatch(async (self, quantity, params) => {
+    if (self.params.callbacks?.onCalculate) {
+        await self.params.callbacks.onCalculate(quantity, params);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientSizing CALL_CALCULATE_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Main calculation function routing to specific sizing method.
  * Applies min/max constraints after calculation.
@@ -4349,9 +5351,7 @@ const CALCULATE_FN = async (params, self) => {
         quantity = Math.min(quantity, schema.maxPositionSize);
     }
     // Trigger callback if defined
-    if (schema.callbacks?.onCalculate) {
-        schema.callbacks.onCalculate(quantity, params);
-    }
+    await CALL_CALCULATE_CALLBACKS_FN(self, quantity, params);
     return quantity;
 };
 /**
@@ -4467,6 +5467,50 @@ const get = (object, path) => {
 
 /** Symbol indicating that positions need to be fetched from persistence */
 const POSITION_NEED_FETCH = Symbol("risk-need-fetch");
+/**
+ * Converts signal to risk validation format.
+ *
+ * This function is used BEFORE position opens during risk checks.
+ * It ensures all required fields are present for risk validation:
+ *
+ * - Falls back to currentPrice if priceOpen is not set (for ISignalDto/scheduled signals)
+ * - Replaces priceStopLoss with trailing SL if active (for positions with trailing stops)
+ * - Preserves original stop-loss in originalPriceStopLoss for reference
+ *
+ * Use cases:
+ * - Risk validation before opening a position (checkSignal)
+ * - Pre-flight validation of scheduled signals
+ * - Calculating position size based on stop-loss distance
+ *
+ * @param signal - Signal DTO or row (may not have priceOpen for scheduled signals)
+ * @param currentPrice - Current market price, used as fallback for priceOpen if not set
+ * @returns Signal in IRiskSignalRow format with guaranteed priceOpen and effective stop-loss
+ *
+ * @example
+ * ```typescript
+ * // For scheduled signal without priceOpen
+ * const riskSignal = TO_RISK_SIGNAL(scheduledSignal, 45000);
+ * // riskSignal.priceOpen = 45000 (fallback to currentPrice)
+ *
+ * // For signal with trailing SL
+ * const riskSignal = TO_RISK_SIGNAL(activeSignal, 46000);
+ * // riskSignal.priceStopLoss = activeSignal._trailingPriceStopLoss
+ * ```
+ */
+const TO_RISK_SIGNAL = (signal, currentPrice) => {
+    if ("_trailingPriceStopLoss" in signal) {
+        return {
+            ...signal,
+            priceStopLoss: signal._trailingPriceStopLoss,
+            originalPriceStopLoss: signal.priceStopLoss,
+        };
+    }
+    return {
+        ...signal,
+        priceOpen: signal.priceOpen ?? currentPrice,
+        originalPriceStopLoss: signal.priceStopLoss,
+    };
+};
 /** Key generator for active position map */
 const CREATE_NAME_FN = (strategyName, exchangeName, symbol) => `${strategyName}_${exchangeName}_${symbol}`;
 /** Wrapper to execute risk validation function with error handling */
@@ -4486,7 +5530,41 @@ const DO_VALIDATION_FN = async (validation, params) => {
         return payload.message;
     }
 };
-/**
+/** Wrapper to call onRejected callback with error handling */
+const CALL_REJECTED_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, params) => {
+    if (self.params.callbacks?.onRejected) {
+        await self.params.callbacks.onRejected(symbol, params);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientRisk CALL_REJECTED_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/** Wrapper to call onAllowed callback with error handling */
+const CALL_ALLOWED_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, params) => {
+    if (self.params.callbacks?.onAllowed) {
+        await self.params.callbacks.onAllowed(symbol, params);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientRisk CALL_ALLOWED_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
  * Initializes active positions by reading from persistence.
  * Uses singleshot pattern to ensure it only runs once.
  * This function is exported for use in tests or other modules.
@@ -4556,6 +5634,7 @@ class ClientRisk {
             const riskMap = this._activePositions;
             const payload = {
                 ...params,
+                pendingSignal: TO_RISK_SIGNAL(params.pendingSignal, params.currentPrice),
                 activePositionCount: riskMap.size,
                 activePositions: Array.from(riskMap.values()),
             };
@@ -4590,15 +5669,11 @@ class ClientRisk {
                 // Call params.onRejected for riskSubject emission
                 await this.params.onRejected(params.symbol, params, riskMap.size, rejectionResult, params.timestamp, this.params.backtest);
                 // Call schema callbacks.onRejected if defined
-                if (this.params.callbacks?.onRejected) {
-                    this.params.callbacks.onRejected(params.symbol, params);
-                }
+                await CALL_REJECTED_CALLBACKS_FN(this, params.symbol, params);
                 return false;
             }
             // All checks passed
-            if (this.params.callbacks?.onAllowed) {
-                this.params.callbacks.onAllowed(params.symbol, params);
-            }
+            await CALL_ALLOWED_CALLBACKS_FN(this, params.symbol, params);
             return true;
         };
     }
@@ -5210,6 +6285,118 @@ class StrategyCoreService {
             }
             return await this.strategyConnectionService.clear(payload);
         };
+        /**
+         * Executes partial close at profit level (moving toward TP).
+         *
+         * Validates strategy existence and delegates to connection service
+         * to close a percentage of the pending position at profit.
+         *
+         * 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 percentToClose - Percentage of position to close (0-100, absolute value)
+         * @param currentPrice - Current market price for this partial close (must be in profit direction)
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise that resolves when state is updated and persisted
+         *
+         * @example
+         * ```typescript
+         * // Close 30% of position at profit
+         * await strategyCoreService.partialProfit(
+         *   false,
+         *   "BTCUSDT",
+         *   30,
+         *   45000,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+         * );
+         * ```
+         */
+        this.partialProfit = async (backtest, symbol, percentToClose, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService partialProfit", {
+                symbol,
+                percentToClose,
+                currentPrice,
+                context,
+                backtest,
+            });
+            await this.validate(symbol, context);
+            return await this.strategyConnectionService.partialProfit(backtest, symbol, percentToClose, currentPrice, context);
+        };
+        /**
+         * Executes partial close at loss level (moving toward SL).
+         *
+         * Validates strategy existence and delegates to connection service
+         * to close a percentage of the pending position at loss.
+         *
+         * 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 percentToClose - Percentage of position to close (0-100, absolute value)
+         * @param currentPrice - Current market price for this partial close (must be in loss direction)
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise that resolves when state is updated and persisted
+         *
+         * @example
+         * ```typescript
+         * // Close 40% of position at loss
+         * await strategyCoreService.partialLoss(
+         *   false,
+         *   "BTCUSDT",
+         *   40,
+         *   38000,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" }
+         * );
+         * ```
+         */
+        this.partialLoss = async (backtest, symbol, percentToClose, currentPrice, context) => {
+            this.loggerService.log("strategyCoreService partialLoss", {
+                symbol,
+                percentToClose,
+                currentPrice,
+                context,
+                backtest,
+            });
+            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);
+        };
     }
 }
 
@@ -6350,6 +7537,104 @@ class LiveLogicPrivateService {
     }
 }
 
+/**
+ * Wrapper to call onStrategyStart callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param walkerSchema - Walker schema containing callbacks
+ * @param strategyName - Name of the strategy being tested
+ * @param symbol - Trading pair symbol
+ */
+const CALL_STRATEGY_START_CALLBACKS_FN = functoolsKit.trycatch(async (walkerSchema, strategyName, symbol) => {
+    if (walkerSchema.callbacks?.onStrategyStart) {
+        await walkerSchema.callbacks.onStrategyStart(strategyName, symbol);
+    }
+}, {
+    fallback: (error) => {
+        const message = "WalkerLogicPrivateService CALL_STRATEGY_START_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Wrapper to call onStrategyError callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param walkerSchema - Walker schema containing callbacks
+ * @param strategyName - Name of the strategy that failed
+ * @param symbol - Trading pair symbol
+ * @param error - Error that occurred during strategy execution
+ */
+const CALL_STRATEGY_ERROR_CALLBACKS_FN = functoolsKit.trycatch(async (walkerSchema, strategyName, symbol, error) => {
+    if (walkerSchema.callbacks?.onStrategyError) {
+        await walkerSchema.callbacks.onStrategyError(strategyName, symbol, error);
+    }
+}, {
+    fallback: (error) => {
+        const message = "WalkerLogicPrivateService CALL_STRATEGY_ERROR_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Wrapper to call onStrategyComplete callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param walkerSchema - Walker schema containing callbacks
+ * @param strategyName - Name of the strategy that completed
+ * @param symbol - Trading pair symbol
+ * @param stats - Backtest statistics for the strategy
+ * @param metricValue - Calculated metric value for comparison
+ */
+const CALL_STRATEGY_COMPLETE_CALLBACKS_FN = functoolsKit.trycatch(async (walkerSchema, strategyName, symbol, stats, metricValue) => {
+    if (walkerSchema.callbacks?.onStrategyComplete) {
+        await walkerSchema.callbacks.onStrategyComplete(strategyName, symbol, stats, metricValue);
+    }
+}, {
+    fallback: (error) => {
+        const message = "WalkerLogicPrivateService CALL_STRATEGY_COMPLETE_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Wrapper to call onComplete callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param walkerSchema - Walker schema containing callbacks
+ * @param finalResults - Final results with all strategies ranked
+ */
+const CALL_COMPLETE_CALLBACKS_FN = functoolsKit.trycatch(async (walkerSchema, finalResults) => {
+    if (walkerSchema.callbacks?.onComplete) {
+        await walkerSchema.callbacks.onComplete(finalResults);
+    }
+}, {
+    fallback: (error) => {
+        const message = "WalkerLogicPrivateService CALL_COMPLETE_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Private service for walker orchestration (strategy comparison).
  *
@@ -6435,9 +7720,7 @@ class WalkerLogicPrivateService {
                     break;
                 }
                 // Call onStrategyStart callback if provided
-                if (walkerSchema.callbacks?.onStrategyStart) {
-                    walkerSchema.callbacks.onStrategyStart(strategyName, symbol);
-                }
+                await CALL_STRATEGY_START_CALLBACKS_FN(walkerSchema, strategyName, symbol);
                 this.loggerService.info("walkerLogicPrivateService testing strategy", {
                     strategyName,
                     symbol,
@@ -6459,9 +7742,7 @@ class WalkerLogicPrivateService {
                     });
                     await errorEmitter.next(error);
                     // Call onStrategyError callback if provided
-                    if (walkerSchema.callbacks?.onStrategyError) {
-                        walkerSchema.callbacks.onStrategyError(strategyName, symbol, error);
-                    }
+                    await CALL_STRATEGY_ERROR_CALLBACKS_FN(walkerSchema, strategyName, symbol, error);
                     continue;
                 }
                 this.loggerService.info("walkerLogicPrivateService backtest complete", {
@@ -6512,9 +7793,7 @@ class WalkerLogicPrivateService {
                     progress: strategies.length > 0 ? strategiesTested / strategies.length : 0,
                 });
                 // Call onStrategyComplete callback if provided
-                if (walkerSchema.callbacks?.onStrategyComplete) {
-                    await walkerSchema.callbacks.onStrategyComplete(strategyName, symbol, stats, metricValue);
-                }
+                await CALL_STRATEGY_COMPLETE_CALLBACKS_FN(walkerSchema, strategyName, symbol, stats, metricValue);
                 await walkerEmitter.next(walkerContract);
                 yield walkerContract;
             }
@@ -6537,9 +7816,7 @@ class WalkerLogicPrivateService {
                 : null,
         };
         // Call onComplete callback if provided with final best results
-        if (walkerSchema.callbacks?.onComplete) {
-            walkerSchema.callbacks.onComplete(finalResults);
-        }
+        await CALL_COMPLETE_CALLBACKS_FN(walkerSchema, finalResults);
         await walkerCompleteSubject.next(finalResults);
     }
 }
@@ -6932,6 +8209,21 @@ const backtest_columns = [
         },
         isVisible: () => true,
     },
+    {
+        key: "partialCloses",
+        label: "Partial Closes",
+        format: (data) => {
+            const partial = data.signal._partial;
+            if (!partial || partial.length === 0)
+                return "N/A";
+            const profitCount = partial.filter(p => p.type === "profit").length;
+            const lossCount = partial.filter(p => p.type === "loss").length;
+            const profitPercent = partial.filter(p => p.type === "profit").reduce((sum, p) => sum + p.percent, 0);
+            const lossPercent = partial.filter(p => p.type === "loss").reduce((sum, p) => sum + p.percent, 0);
+            return `${partial.length} (↑${profitCount}: ${profitPercent.toFixed(1)}%, ↓${lossCount}: ${lossPercent.toFixed(1)}%)`;
+        },
+        isVisible: () => true,
+    },
     {
         key: "closeReason",
         label: "Close Reason",
@@ -7007,49 +8299,49 @@ const heat_columns = [
     {
         key: "totalPnl",
         label: "Total PNL",
-        format: (data) => data.totalPnl !== null ? functoolsKit.str(data.totalPnl, "%+.2f%%") : "N/A",
+        format: (data) => data.totalPnl !== null ? functoolsKit.str(data.totalPnl, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "sharpeRatio",
         label: "Sharpe",
-        format: (data) => data.sharpeRatio !== null ? functoolsKit.str(data.sharpeRatio, "%.2f") : "N/A",
+        format: (data) => data.sharpeRatio !== null ? functoolsKit.str(data.sharpeRatio) : "N/A",
         isVisible: () => true,
     },
     {
         key: "profitFactor",
         label: "PF",
-        format: (data) => data.profitFactor !== null ? functoolsKit.str(data.profitFactor, "%.2f") : "N/A",
+        format: (data) => data.profitFactor !== null ? functoolsKit.str(data.profitFactor) : "N/A",
         isVisible: () => true,
     },
     {
         key: "expectancy",
         label: "Expect",
-        format: (data) => data.expectancy !== null ? functoolsKit.str(data.expectancy, "%+.2f%%") : "N/A",
+        format: (data) => data.expectancy !== null ? functoolsKit.str(data.expectancy, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "winRate",
         label: "WR",
-        format: (data) => data.winRate !== null ? functoolsKit.str(data.winRate, "%.1f%%") : "N/A",
+        format: (data) => data.winRate !== null ? functoolsKit.str(data.winRate, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "avgWin",
         label: "Avg Win",
-        format: (data) => data.avgWin !== null ? functoolsKit.str(data.avgWin, "%+.2f%%") : "N/A",
+        format: (data) => data.avgWin !== null ? functoolsKit.str(data.avgWin, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "avgLoss",
         label: "Avg Loss",
-        format: (data) => data.avgLoss !== null ? functoolsKit.str(data.avgLoss, "%+.2f%%") : "N/A",
+        format: (data) => data.avgLoss !== null ? functoolsKit.str(data.avgLoss, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "maxDrawdown",
         label: "Max DD",
-        format: (data) => data.maxDrawdown !== null ? functoolsKit.str(-data.maxDrawdown, "%.2f%%") : "N/A",
+        format: (data) => data.maxDrawdown !== null ? functoolsKit.str(-data.maxDrawdown, "%") : "N/A",
         isVisible: () => true,
     },
     {
@@ -8287,7 +9579,7 @@ class BacktestMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("backtestMarkdownService init");
-            signalBacktestEmitter.subscribe(this.tick);
+            this.unsubscribe = signalBacktestEmitter.subscribe(this.tick);
         });
     }
 }
@@ -8816,7 +10108,7 @@ class LiveMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("liveMarkdownService init");
-            signalLiveEmitter.subscribe(this.tick);
+            this.unsubscribe = signalLiveEmitter.subscribe(this.tick);
         });
     }
 }
@@ -9245,7 +10537,7 @@ class ScheduleMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("scheduleMarkdownService init");
-            signalEmitter.subscribe(this.tick);
+            this.unsubscribe = signalEmitter.subscribe(this.tick);
         });
     }
 }
@@ -9613,7 +10905,7 @@ class PerformanceMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("performanceMarkdownService init");
-            performanceEmitter.subscribe(this.track);
+            this.unsubscribe = performanceEmitter.subscribe(this.track);
         });
     }
 }
@@ -10022,7 +11314,7 @@ class WalkerMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("walkerMarkdownService init");
-            walkerEmitter.subscribe(this.tick);
+            this.unsubscribe = walkerEmitter.subscribe(this.tick);
         });
     }
 }
@@ -10324,7 +11616,7 @@ class HeatmapStorage {
         return [
             `# Portfolio Heatmap: ${strategyName}`,
             "",
-            `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? functoolsKit.str(data.portfolioTotalPnl, "%+.2f%%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? functoolsKit.str(data.portfolioSharpeRatio, "%.2f") : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades}`,
+            `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? functoolsKit.str(data.portfolioTotalPnl, "%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? functoolsKit.str(data.portfolioSharpeRatio) : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades}`,
             "",
             table
         ].join("\n");
@@ -10549,7 +11841,7 @@ class HeatMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("heatMarkdownService init");
-            signalEmitter.subscribe(this.tick);
+            this.unsubscribe = signalEmitter.subscribe(this.tick);
         });
     }
 }
@@ -11428,12 +12720,16 @@ class OptimizerTemplateService {
                 ``,
                 `listenWalkerComplete((results) => {`,
                 `    console.log("Walker completed:", results.bestStrategy);`,
-                `    Walker.dump("${escapedSymbol}", results.walkerName);`,
+                `    Walker.dump(results.symbol, { walkerName: results.walkerName });`,
                 `});`,
                 ``,
                 `listenDoneBacktest((event) => {`,
                 `    console.log("Backtest completed:", event.symbol);`,
-                `    Backtest.dump(event.symbol, event.strategyName);`,
+                `    Backtest.dump(event.symbol, {`,
+                `        strategyName: event.strategyName,`,
+                `        exchangeName: event.exchangeName,`,
+                `        frameName: event.frameName`,
+                `    });`,
                 `});`,
                 ``,
                 `listenError((error) => {`,
@@ -11467,12 +12763,10 @@ class OptimizerTemplateService {
                 `    }`,
                 ``,
                 `    {`,
-                `        let summary = "# Outline Result Summary\\n";`,
+                `        let summary = "# Outline Result Summary\\n\\n";`,
                 ``,
                 `        {`,
-                `            summary += "\\n";`,
-                `            summary += \`**ResultId**: \${resultId}\\n\`;`,
-                `            summary += "\\n";`,
+                `            summary += \`**ResultId**: \${resultId}\\n\\n\`;`,
                 `        }`,
                 ``,
                 `        if (result) {`,
@@ -11488,7 +12782,7 @@ class OptimizerTemplateService {
                 `            systemMessages.forEach((msg, idx) => {`,
                 `                summary += \`### System Message \${idx + 1}\\n\\n\`;`,
                 `                summary += msg.content;`,
-                `                summary += "\\n";`,
+                `                summary += "\\n\\n";`,
                 `            });`,
                 `        }`,
                 ``,
@@ -13311,8 +14605,9 @@ class PartialMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("partialMarkdownService init");
-            partialProfitSubject.subscribe(this.tickProfit);
-            partialLossSubject.subscribe(this.tickLoss);
+            const unProfit = partialProfitSubject.subscribe(this.tickProfit);
+            const unLoss = partialLossSubject.subscribe(this.tickLoss);
+            this.unsubscribe = functoolsKit.compose(() => unProfit(), () => unLoss());
         });
     }
 }
@@ -14057,7 +15352,7 @@ class RiskMarkdownService {
          */
         this.init = functoolsKit.singleshot(async () => {
             this.loggerService.log("riskMarkdownService init");
-            riskSubject.subscribe(this.tickRejection);
+            this.unsubscribe = riskSubject.subscribe(this.tickRejection);
         });
     }
 }
@@ -14512,95 +15807,402 @@ const validateInternal = async (args) => {
  *
  * @example
  * ```typescript
- * // Validate specific entity types
- * await validate({
- *   RiskName: { CONSERVATIVE: "conservative" },
- *   SizingName: { FIXED_1000: "fixed-1000" },
- * });
+ * // Validate specific entity types
+ * await validate({
+ *   RiskName: { CONSERVATIVE: "conservative" },
+ *   SizingName: { FIXED_1000: "fixed-1000" },
+ * });
+ * ```
+ */
+async function validate(args = {}) {
+    backtest$1.loggerService.log(METHOD_NAME);
+    return await validateInternal(args);
+}
+
+const GET_CANDLES_METHOD_NAME = "exchange.getCandles";
+const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
+const FORMAT_PRICE_METHOD_NAME = "exchange.formatPrice";
+const FORMAT_QUANTITY_METHOD_NAME = "exchange.formatQuantity";
+const GET_DATE_METHOD_NAME = "exchange.getDate";
+const GET_MODE_METHOD_NAME = "exchange.getMode";
+const HAS_TRADE_CONTEXT_METHOD_NAME = "exchange.hasTradeContext";
+/**
+ * Checks if trade context is active (execution and method contexts).
+ *
+ * Returns true when both contexts are active, which is required for calling
+ * exchange functions like getCandles, getAveragePrice, formatPrice, formatQuantity,
+ * getDate, and getMode.
+ *
+ * @returns true if trade context is active, false otherwise
+ *
+ * @example
+ * ```typescript
+ * import { hasTradeContext, getCandles } from "backtest-kit";
+ *
+ * if (hasTradeContext()) {
+ *   const candles = await getCandles("BTCUSDT", "1m", 100);
+ * } else {
+ *   console.log("Trade context not active");
+ * }
+ * ```
+ */
+function hasTradeContext() {
+    backtest$1.loggerService.info(HAS_TRADE_CONTEXT_METHOD_NAME);
+    return ExecutionContextService.hasContext() && MethodContextService.hasContext();
+}
+/**
+ * Fetches historical candle data from the registered exchange.
+ *
+ * Candles are fetched backwards from the current execution context time.
+ * Uses the exchange's getCandles implementation.
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param interval - Candle interval ("1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "6h" | "8h")
+ * @param limit - Number of candles to fetch
+ * @returns Promise resolving to array of candle data
+ *
+ * @example
+ * ```typescript
+ * const candles = await getCandles("BTCUSDT", "1m", 100);
+ * console.log(candles[0]); // { timestamp, open, high, low, close, volume }
+ * ```
+ */
+async function getCandles(symbol, interval, limit) {
+    backtest$1.loggerService.info(GET_CANDLES_METHOD_NAME, {
+        symbol,
+        interval,
+        limit,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getCandles requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getCandles requires a method context");
+    }
+    return await backtest$1.exchangeConnectionService.getCandles(symbol, interval, limit);
+}
+/**
+ * Calculates VWAP (Volume Weighted Average Price) for a symbol.
+ *
+ * Uses the last 5 1-minute candles to calculate:
+ * - Typical Price = (high + low + close) / 3
+ * - VWAP = sum(typical_price * volume) / sum(volume)
+ *
+ * If volume is zero, returns simple average of close prices.
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @returns Promise resolving to VWAP price
+ *
+ * @example
+ * ```typescript
+ * const vwap = await getAveragePrice("BTCUSDT");
+ * console.log(vwap); // 50125.43
+ * ```
+ */
+async function getAveragePrice(symbol) {
+    backtest$1.loggerService.info(GET_AVERAGE_PRICE_METHOD_NAME, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getAveragePrice requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getAveragePrice requires a method context");
+    }
+    return await backtest$1.exchangeConnectionService.getAveragePrice(symbol);
+}
+/**
+ * Formats a price value according to exchange rules.
+ *
+ * Uses the exchange's formatPrice implementation for proper decimal places.
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param price - Raw price value
+ * @returns Promise resolving to formatted price string
+ *
+ * @example
+ * ```typescript
+ * const formatted = await formatPrice("BTCUSDT", 50000.123456);
+ * console.log(formatted); // "50000.12"
+ * ```
+ */
+async function formatPrice(symbol, price) {
+    backtest$1.loggerService.info(FORMAT_PRICE_METHOD_NAME, {
+        symbol,
+        price,
+    });
+    if (!MethodContextService.hasContext()) {
+        throw new Error("formatPrice requires a method context");
+    }
+    return await backtest$1.exchangeConnectionService.formatPrice(symbol, price);
+}
+/**
+ * Formats a quantity value according to exchange rules.
+ *
+ * Uses the exchange's formatQuantity implementation for proper decimal places.
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param quantity - Raw quantity value
+ * @returns Promise resolving to formatted quantity string
+ *
+ * @example
+ * ```typescript
+ * const formatted = await formatQuantity("BTCUSDT", 0.123456789);
+ * console.log(formatted); // "0.12345678"
+ * ```
+ */
+async function formatQuantity(symbol, quantity) {
+    backtest$1.loggerService.info(FORMAT_QUANTITY_METHOD_NAME, {
+        symbol,
+        quantity,
+    });
+    if (!MethodContextService.hasContext()) {
+        throw new Error("formatQuantity requires a method context");
+    }
+    return await backtest$1.exchangeConnectionService.formatQuantity(symbol, quantity);
+}
+/**
+ * Gets the current date from execution context.
+ *
+ * In backtest mode: returns the current timeframe date being processed
+ * In live mode: returns current real-time date
+ *
+ * @returns Promise resolving to current execution context date
+ *
+ * @example
+ * ```typescript
+ * const date = await getDate();
+ * console.log(date); // 2024-01-01T12:00:00.000Z
+ * ```
+ */
+async function getDate() {
+    backtest$1.loggerService.info(GET_DATE_METHOD_NAME);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getDate requires an execution context");
+    }
+    const { when } = backtest$1.executionContextService.context;
+    return new Date(when.getTime());
+}
+/**
+ * Gets the current execution mode.
+ *
+ * @returns Promise resolving to "backtest" or "live"
+ *
+ * @example
+ * ```typescript
+ * const mode = await getMode();
+ * if (mode === "backtest") {
+ *   console.log("Running in backtest mode");
+ * } else {
+ *   console.log("Running in live mode");
+ * }
+ * ```
+ */
+async function getMode() {
+    backtest$1.loggerService.info(GET_MODE_METHOD_NAME);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getMode requires an execution context");
+    }
+    const { backtest: bt } = backtest$1.executionContextService.context;
+    return bt ? "backtest" : "live";
+}
+
+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.
+ *
+ * Sets internal flag to prevent strategy from opening new signals.
+ * Current active signal (if any) will complete normally.
+ * Backtest/Live mode will stop at the next safe point (idle state or after signal closes).
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param strategyName - Strategy name to stop
+ * @returns Promise that resolves when stop flag is set
+ *
+ * @example
+ * ```typescript
+ * import { stop } from "backtest-kit";
+ *
+ * // Stop strategy after some condition
+ * await stop("BTCUSDT", "my-strategy");
+ * ```
+ */
+async function stop(symbol) {
+    backtest$1.loggerService.info(STOP_METHOD_NAME, {
+        symbol,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("stop requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("stop requires a method context");
+    }
+    const { backtest: isBacktest } = backtest$1.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest$1.methodContextService.context;
+    await backtest$1.strategyCoreService.stop(isBacktest, symbol, {
+        exchangeName,
+        frameName,
+        strategyName,
+    });
+}
+/**
+ * Cancels the scheduled signal without stopping the strategy.
+ *
+ * Clears the scheduled signal (waiting for priceOpen activation).
+ * Does NOT affect active pending signals or strategy operation.
+ * Does NOT set stop flag - strategy can continue generating new signals.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param strategyName - Strategy name
+ * @param cancelId - Optional cancellation ID for tracking user-initiated cancellations
+ * @returns Promise that resolves when scheduled signal is cancelled
+ *
+ * @example
+ * ```typescript
+ * import { cancel } from "backtest-kit";
+ *
+ * // Cancel scheduled signal with custom ID
+ * await cancel("BTCUSDT", "my-strategy", "manual-cancel-001");
+ * ```
+ */
+async function cancel(symbol, cancelId) {
+    backtest$1.loggerService.info(CANCEL_METHOD_NAME, {
+        symbol,
+        cancelId,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("cancel requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("cancel requires a method context");
+    }
+    const { backtest: isBacktest } = backtest$1.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest$1.methodContextService.context;
+    await backtest$1.strategyCoreService.cancel(isBacktest, symbol, { exchangeName, frameName, strategyName }, cancelId);
+}
+/**
+ * Executes partial close at profit level (moving toward TP).
+ *
+ * Closes a percentage of the active pending position at profit.
+ * Price must be moving toward take profit (in profit direction).
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param percentToClose - Percentage of position to close (0-100, absolute value)
+ * @returns Promise that resolves when state is updated
+ *
+ * @throws Error if currentPrice is not in profit direction:
+ *   - LONG: currentPrice must be > priceOpen
+ *   - SHORT: currentPrice must be < priceOpen
+ *
+ * @example
+ * ```typescript
+ * import { partialProfit } from "backtest-kit";
+ *
+ * // Close 30% of LONG position at profit
+ * await partialProfit("BTCUSDT", 30, 45000);
  * ```
  */
-async function validate(args = {}) {
-    backtest$1.loggerService.log(METHOD_NAME);
-    return await validateInternal(args);
+async function partialProfit(symbol, percentToClose) {
+    backtest$1.loggerService.info(PARTIAL_PROFIT_METHOD_NAME, {
+        symbol,
+        percentToClose,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("partialProfit requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("partialProfit requires a method context");
+    }
+    const currentPrice = await getAveragePrice(symbol);
+    const { backtest: isBacktest } = backtest$1.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest$1.methodContextService.context;
+    await backtest$1.strategyCoreService.partialProfit(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
 }
-
-const STOP_METHOD_NAME = "strategy.stop";
-const CANCEL_METHOD_NAME = "strategy.cancel";
 /**
- * Stops the strategy from generating new signals.
+ * Executes partial close at loss level (moving toward SL).
  *
- * Sets internal flag to prevent strategy from opening new signals.
- * Current active signal (if any) will complete normally.
- * Backtest/Live mode will stop at the next safe point (idle state or after signal closes).
+ * Closes a percentage of the active pending position at loss.
+ * Price must be moving toward stop loss (in loss direction).
  *
  * Automatically detects backtest/live mode from execution context.
  *
  * @param symbol - Trading pair symbol
- * @param strategyName - Strategy name to stop
- * @returns Promise that resolves when stop flag is set
+ * @param percentToClose - Percentage of position to close (0-100, absolute value)
+ * @returns Promise that resolves when state is updated
+ *
+ * @throws Error if currentPrice is not in loss direction:
+ *   - LONG: currentPrice must be < priceOpen
+ *   - SHORT: currentPrice must be > priceOpen
  *
  * @example
  * ```typescript
- * import { stop } from "backtest-kit";
+ * import { partialLoss } from "backtest-kit";
  *
- * // Stop strategy after some condition
- * await stop("BTCUSDT", "my-strategy");
+ * // Close 40% of LONG position at loss
+ * await partialLoss("BTCUSDT", 40, 38000);
  * ```
  */
-async function stop(symbol) {
-    backtest$1.loggerService.info(STOP_METHOD_NAME, {
+async function partialLoss(symbol, percentToClose) {
+    backtest$1.loggerService.info(PARTIAL_LOSS_METHOD_NAME, {
         symbol,
+        percentToClose,
     });
     if (!ExecutionContextService.hasContext()) {
-        throw new Error("stop requires an execution context");
+        throw new Error("partialLoss requires an execution context");
     }
     if (!MethodContextService.hasContext()) {
-        throw new Error("stop requires a method context");
+        throw new Error("partialLoss requires a method context");
     }
+    const currentPrice = await getAveragePrice(symbol);
     const { backtest: isBacktest } = backtest$1.executionContextService.context;
     const { exchangeName, frameName, strategyName } = backtest$1.methodContextService.context;
-    await backtest$1.strategyCoreService.stop(isBacktest, symbol, {
-        exchangeName,
-        frameName,
-        strategyName,
-    });
+    await backtest$1.strategyCoreService.partialLoss(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
 }
 /**
- * Cancels the scheduled signal without stopping the strategy.
+ * Adjusts the trailing stop-loss distance for an active pending signal.
  *
- * Clears the scheduled signal (waiting for priceOpen activation).
- * Does NOT affect active pending signals or strategy operation.
- * Does NOT set stop flag - strategy can continue generating new signals.
+ * 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 strategyName - Strategy name
- * @param cancelId - Optional cancellation ID for tracking user-initiated cancellations
- * @returns Promise that resolves when scheduled signal is cancelled
+ * @param percentShift - Percentage adjustment to SL distance (-100 to 100)
+ * @returns Promise that resolves when trailing SL is updated
  *
  * @example
  * ```typescript
- * import { cancel } from "backtest-kit";
+ * import { trailingStop } from "backtest-kit";
  *
- * // Cancel scheduled signal with custom ID
- * await cancel("BTCUSDT", "my-strategy", "manual-cancel-001");
+ * // LONG: entry=100, originalSL=90, distance=10
+ * // Tighten stop by 50%: newSL = 100 - 10*(1-0.5) = 95
+ * await trailingStop("BTCUSDT", -50);
  * ```
  */
-async function cancel(symbol, cancelId) {
-    backtest$1.loggerService.info(CANCEL_METHOD_NAME, {
+async function trailingStop(symbol, percentShift) {
+    backtest$1.loggerService.info(TRAILING_STOP_METHOD_NAME, {
         symbol,
-        cancelId,
+        percentShift,
     });
     if (!ExecutionContextService.hasContext()) {
-        throw new Error("cancel requires an execution context");
+        throw new Error("trailingStop requires an execution context");
     }
     if (!MethodContextService.hasContext()) {
-        throw new Error("cancel requires a method context");
+        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.cancel(isBacktest, symbol, { exchangeName, frameName, strategyName }, cancelId);
+    await backtest$1.strategyCoreService.trailingStop(isBacktest, symbol, percentShift, { exchangeName, frameName, strategyName });
 }
 
 /**
@@ -16318,224 +17920,36 @@ function listenPing(fn) {
 /**
  * Subscribes to filtered ping events with one-time execution.
  *
- * Listens for events matching the filter predicate, then executes callback once
- * and automatically unsubscribes. Useful for waiting for specific ping conditions.
- *
- * @param filterFn - Predicate to filter which events trigger the callback
- * @param fn - Callback function to handle the filtered event (called only once)
- * @returns Unsubscribe function to cancel the listener before it fires
- *
- * @example
- * ```typescript
- * import { listenPingOnce } from "./function/event";
- *
- * // Wait for first ping on BTCUSDT
- * listenPingOnce(
- *   (event) => event.symbol === "BTCUSDT",
- *   (event) => console.log("First BTCUSDT ping received")
- * );
- *
- * // Wait for ping in backtest mode
- * const cancel = listenPingOnce(
- *   (event) => event.backtest === true,
- *   (event) => console.log("Backtest ping received at", new Date(event.timestamp))
- * );
- *
- * // Cancel if needed before event fires
- * cancel();
- * ```
- */
-function listenPingOnce(filterFn, fn) {
-    backtest$1.loggerService.log(LISTEN_PING_ONCE_METHOD_NAME);
-    return pingSubject.filter(filterFn).once(fn);
-}
-
-const GET_CANDLES_METHOD_NAME = "exchange.getCandles";
-const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
-const FORMAT_PRICE_METHOD_NAME = "exchange.formatPrice";
-const FORMAT_QUANTITY_METHOD_NAME = "exchange.formatQuantity";
-const GET_DATE_METHOD_NAME = "exchange.getDate";
-const GET_MODE_METHOD_NAME = "exchange.getMode";
-const HAS_TRADE_CONTEXT_METHOD_NAME = "exchange.hasTradeContext";
-/**
- * Checks if trade context is active (execution and method contexts).
- *
- * Returns true when both contexts are active, which is required for calling
- * exchange functions like getCandles, getAveragePrice, formatPrice, formatQuantity,
- * getDate, and getMode.
- *
- * @returns true if trade context is active, false otherwise
- *
- * @example
- * ```typescript
- * import { hasTradeContext, getCandles } from "backtest-kit";
- *
- * if (hasTradeContext()) {
- *   const candles = await getCandles("BTCUSDT", "1m", 100);
- * } else {
- *   console.log("Trade context not active");
- * }
- * ```
- */
-function hasTradeContext() {
-    backtest$1.loggerService.info(HAS_TRADE_CONTEXT_METHOD_NAME);
-    return ExecutionContextService.hasContext() && MethodContextService.hasContext();
-}
-/**
- * Fetches historical candle data from the registered exchange.
- *
- * Candles are fetched backwards from the current execution context time.
- * Uses the exchange's getCandles implementation.
- *
- * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
- * @param interval - Candle interval ("1m" | "3m" | "5m" | "15m" | "30m" | "1h" | "2h" | "4h" | "6h" | "8h")
- * @param limit - Number of candles to fetch
- * @returns Promise resolving to array of candle data
- *
- * @example
- * ```typescript
- * const candles = await getCandles("BTCUSDT", "1m", 100);
- * console.log(candles[0]); // { timestamp, open, high, low, close, volume }
- * ```
- */
-async function getCandles(symbol, interval, limit) {
-    backtest$1.loggerService.info(GET_CANDLES_METHOD_NAME, {
-        symbol,
-        interval,
-        limit,
-    });
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("getCandles requires an execution context");
-    }
-    if (!MethodContextService.hasContext()) {
-        throw new Error("getCandles requires a method context");
-    }
-    return await backtest$1.exchangeConnectionService.getCandles(symbol, interval, limit);
-}
-/**
- * Calculates VWAP (Volume Weighted Average Price) for a symbol.
- *
- * Uses the last 5 1-minute candles to calculate:
- * - Typical Price = (high + low + close) / 3
- * - VWAP = sum(typical_price * volume) / sum(volume)
- *
- * If volume is zero, returns simple average of close prices.
- *
- * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
- * @returns Promise resolving to VWAP price
- *
- * @example
- * ```typescript
- * const vwap = await getAveragePrice("BTCUSDT");
- * console.log(vwap); // 50125.43
- * ```
- */
-async function getAveragePrice(symbol) {
-    backtest$1.loggerService.info(GET_AVERAGE_PRICE_METHOD_NAME, {
-        symbol,
-    });
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("getAveragePrice requires an execution context");
-    }
-    if (!MethodContextService.hasContext()) {
-        throw new Error("getAveragePrice requires a method context");
-    }
-    return await backtest$1.exchangeConnectionService.getAveragePrice(symbol);
-}
-/**
- * Formats a price value according to exchange rules.
- *
- * Uses the exchange's formatPrice implementation for proper decimal places.
- *
- * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
- * @param price - Raw price value
- * @returns Promise resolving to formatted price string
- *
- * @example
- * ```typescript
- * const formatted = await formatPrice("BTCUSDT", 50000.123456);
- * console.log(formatted); // "50000.12"
- * ```
- */
-async function formatPrice(symbol, price) {
-    backtest$1.loggerService.info(FORMAT_PRICE_METHOD_NAME, {
-        symbol,
-        price,
-    });
-    if (!MethodContextService.hasContext()) {
-        throw new Error("formatPrice requires a method context");
-    }
-    return await backtest$1.exchangeConnectionService.formatPrice(symbol, price);
-}
-/**
- * Formats a quantity value according to exchange rules.
- *
- * Uses the exchange's formatQuantity implementation for proper decimal places.
- *
- * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
- * @param quantity - Raw quantity value
- * @returns Promise resolving to formatted quantity string
- *
- * @example
- * ```typescript
- * const formatted = await formatQuantity("BTCUSDT", 0.123456789);
- * console.log(formatted); // "0.12345678"
- * ```
- */
-async function formatQuantity(symbol, quantity) {
-    backtest$1.loggerService.info(FORMAT_QUANTITY_METHOD_NAME, {
-        symbol,
-        quantity,
-    });
-    if (!MethodContextService.hasContext()) {
-        throw new Error("formatQuantity requires a method context");
-    }
-    return await backtest$1.exchangeConnectionService.formatQuantity(symbol, quantity);
-}
-/**
- * Gets the current date from execution context.
- *
- * In backtest mode: returns the current timeframe date being processed
- * In live mode: returns current real-time date
- *
- * @returns Promise resolving to current execution context date
- *
- * @example
- * ```typescript
- * const date = await getDate();
- * console.log(date); // 2024-01-01T12:00:00.000Z
- * ```
- */
-async function getDate() {
-    backtest$1.loggerService.info(GET_DATE_METHOD_NAME);
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("getDate requires an execution context");
-    }
-    const { when } = backtest$1.executionContextService.context;
-    return new Date(when.getTime());
-}
-/**
- * Gets the current execution mode.
- *
- * @returns Promise resolving to "backtest" or "live"
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific ping conditions.
+ *
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @returns Unsubscribe function to cancel the listener before it fires
  *
  * @example
  * ```typescript
- * const mode = await getMode();
- * if (mode === "backtest") {
- *   console.log("Running in backtest mode");
- * } else {
- *   console.log("Running in live mode");
- * }
+ * import { listenPingOnce } from "./function/event";
+ *
+ * // Wait for first ping on BTCUSDT
+ * listenPingOnce(
+ *   (event) => event.symbol === "BTCUSDT",
+ *   (event) => console.log("First BTCUSDT ping received")
+ * );
+ *
+ * // Wait for ping in backtest mode
+ * const cancel = listenPingOnce(
+ *   (event) => event.backtest === true,
+ *   (event) => console.log("Backtest ping received at", new Date(event.timestamp))
+ * );
+ *
+ * // Cancel if needed before event fires
+ * cancel();
  * ```
  */
-async function getMode() {
-    backtest$1.loggerService.info(GET_MODE_METHOD_NAME);
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("getMode requires an execution context");
-    }
-    const { backtest: bt } = backtest$1.executionContextService.context;
-    return bt ? "backtest" : "live";
+function listenPingOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_PING_ONCE_METHOD_NAME);
+    return pingSubject.filter(filterFn).once(fn);
 }
 
 const DUMP_SIGNAL_METHOD_NAME = "dump.dumpSignal";
@@ -16625,6 +18039,9 @@ const BACKTEST_METHOD_NAME_GET_STATUS = "BacktestUtils.getStatus";
 const BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL = "BacktestUtils.getPendingSignal";
 const BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL = "BacktestUtils.getScheduledSignal";
 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.
@@ -16651,6 +18068,7 @@ const INSTANCE_TASK_FN$2 = async (symbol, context, self) => {
         await doneBacktestSubject.next({
             exchangeName: context.exchangeName,
             strategyName: context.strategyName,
+            frameName: context.frameName,
             backtest: true,
             symbol,
         });
@@ -16872,6 +18290,7 @@ class BacktestInstance {
                         await doneBacktestSubject.next({
                             exchangeName: context.exchangeName,
                             strategyName: context.strategyName,
+                            frameName: context.frameName,
                             backtest: true,
                             symbol,
                         });
@@ -16984,6 +18403,10 @@ class BacktestUtils {
          * ```
          */
         this.getPendingSignal = async (symbol, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17011,6 +18434,10 @@ class BacktestUtils {
          * ```
          */
         this.getScheduledSignal = async (symbol, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17044,6 +18471,10 @@ class BacktestUtils {
          * ```
          */
         this.stop = async (symbol, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_STOP, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_STOP);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17078,6 +18509,11 @@ class BacktestUtils {
          * ```
          */
         this.cancel = async (symbol, context, cancelId) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_CANCEL, {
+                symbol,
+                context,
+                cancelId,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CANCEL);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17088,6 +18524,130 @@ class BacktestUtils {
             }
             await backtest$1.strategyCoreService.cancel(true, symbol, context, cancelId);
         };
+        /**
+         * Executes partial close at profit level (moving toward TP).
+         *
+         * Closes a percentage of the active pending position at profit.
+         * Price must be moving toward take profit (in profit direction).
+         *
+         * @param symbol - Trading pair symbol
+         * @param percentToClose - Percentage of position to close (0-100, absolute value)
+         * @param currentPrice - Current market price for this partial close
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Promise that resolves when state is updated
+         *
+         * @throws Error if currentPrice is not in profit direction:
+         *   - LONG: currentPrice must be > priceOpen
+         *   - SHORT: currentPrice must be < priceOpen
+         *
+         * @example
+         * ```typescript
+         * // Close 30% of LONG position at profit
+         * await Backtest.partialProfit("BTCUSDT", 30, 45000, {
+         *   exchangeName: "binance",
+         *   frameName: "frame1",
+         *   strategyName: "my-strategy"
+         * });
+         * ```
+         */
+        this.partialProfit = async (symbol, percentToClose, currentPrice, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_PARTIAL_PROFIT, {
+                symbol,
+                percentToClose,
+                currentPrice,
+                context,
+            });
+            backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT);
+            {
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_PARTIAL_PROFIT));
+            }
+            await backtest$1.strategyCoreService.partialProfit(true, symbol, percentToClose, currentPrice, context);
+        };
+        /**
+         * Executes partial close at loss level (moving toward SL).
+         *
+         * Closes a percentage of the active pending position at loss.
+         * Price must be moving toward stop loss (in loss direction).
+         *
+         * @param symbol - Trading pair symbol
+         * @param percentToClose - Percentage of position to close (0-100, absolute value)
+         * @param currentPrice - Current market price for this partial close
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Promise that resolves when state is updated
+         *
+         * @throws Error if currentPrice is not in loss direction:
+         *   - LONG: currentPrice must be < priceOpen
+         *   - SHORT: currentPrice must be > priceOpen
+         *
+         * @example
+         * ```typescript
+         * // Close 40% of LONG position at loss
+         * await Backtest.partialLoss("BTCUSDT", 40, 38000, {
+         *   exchangeName: "binance",
+         *   frameName: "frame1",
+         *   strategyName: "my-strategy"
+         * });
+         * ```
+         */
+        this.partialLoss = async (symbol, percentToClose, currentPrice, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_PARTIAL_LOSS, {
+                symbol,
+                percentToClose,
+                currentPrice,
+                context,
+            });
+            backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_PARTIAL_LOSS);
+            {
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_PARTIAL_LOSS);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_PARTIAL_LOSS));
+            }
+            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.
          *
@@ -17107,6 +18667,10 @@ class BacktestUtils {
          * ```
          */
         this.getData = async (symbol, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_DATA, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17137,6 +18701,10 @@ class BacktestUtils {
          * ```
          */
         this.getReport = async (symbol, context, columns) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_REPORT, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17174,6 +18742,11 @@ class BacktestUtils {
          * ```
          */
         this.dump = async (symbol, context, path, columns) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_DUMP, {
+                symbol,
+                context,
+                path,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17234,6 +18807,9 @@ const LIVE_METHOD_NAME_GET_STATUS = "LiveUtils.getStatus";
 const LIVE_METHOD_NAME_GET_PENDING_SIGNAL = "LiveUtils.getPendingSignal";
 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.
@@ -17259,6 +18835,7 @@ const INSTANCE_TASK_FN$1 = async (symbol, context, self) => {
         await doneLiveSubject.next({
             exchangeName: context.exchangeName,
             strategyName: context.strategyName,
+            frameName: "",
             backtest: false,
             symbol,
         });
@@ -17445,6 +19022,7 @@ class LiveInstance {
                         await doneLiveSubject.next({
                             exchangeName: context.exchangeName,
                             strategyName: context.strategyName,
+                            frameName: "",
                             backtest: false,
                             symbol,
                         });
@@ -17564,6 +19142,10 @@ class LiveUtils {
          * ```
          */
         this.getPendingSignal = async (symbol, context) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_PENDING_SIGNAL, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17593,6 +19175,10 @@ class LiveUtils {
          * ```
          */
         this.getScheduledSignal = async (symbol, context) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17623,6 +19209,10 @@ class LiveUtils {
          * ```
          */
         this.stop = async (symbol, context) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_STOP, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_STOP);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17659,6 +19249,11 @@ class LiveUtils {
          * ```
          */
         this.cancel = async (symbol, context, cancelId) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_CANCEL, {
+                symbol,
+                context,
+                cancelId,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CANCEL);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17671,6 +19266,133 @@ class LiveUtils {
                 frameName: "",
             }, cancelId);
         };
+        /**
+         * Executes partial close at profit level (moving toward TP).
+         *
+         * Closes a percentage of the active pending position at profit.
+         * Price must be moving toward take profit (in profit direction).
+         *
+         * @param symbol - Trading pair symbol
+         * @param percentToClose - Percentage of position to close (0-100, absolute value)
+         * @param currentPrice - Current market price for this partial close
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise that resolves when state is updated
+         *
+         * @throws Error if currentPrice is not in profit direction:
+         *   - LONG: currentPrice must be > priceOpen
+         *   - SHORT: currentPrice must be < priceOpen
+         *
+         * @example
+         * ```typescript
+         * // Close 30% of LONG position at profit
+         * await Live.partialProfit("BTCUSDT", 30, 45000, {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy"
+         * });
+         * ```
+         */
+        this.partialProfit = async (symbol, percentToClose, currentPrice, context) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_PARTIAL_PROFIT, {
+                symbol,
+                percentToClose,
+                currentPrice,
+                context,
+            });
+            backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_PARTIAL_PROFIT);
+            {
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_PROFIT));
+            }
+            await backtest$1.strategyCoreService.partialProfit(false, symbol, percentToClose, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Executes partial close at loss level (moving toward SL).
+         *
+         * Closes a percentage of the active pending position at loss.
+         * Price must be moving toward stop loss (in loss direction).
+         *
+         * @param symbol - Trading pair symbol
+         * @param percentToClose - Percentage of position to close (0-100, absolute value)
+         * @param currentPrice - Current market price for this partial close
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Promise that resolves when state is updated
+         *
+         * @throws Error if currentPrice is not in loss direction:
+         *   - LONG: currentPrice must be < priceOpen
+         *   - SHORT: currentPrice must be > priceOpen
+         *
+         * @example
+         * ```typescript
+         * // Close 40% of LONG position at loss
+         * await Live.partialLoss("BTCUSDT", 40, 38000, {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy"
+         * });
+         * ```
+         */
+        this.partialLoss = async (symbol, percentToClose, currentPrice, context) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_PARTIAL_LOSS, {
+                symbol,
+                percentToClose,
+                currentPrice,
+                context,
+            });
+            backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_PARTIAL_LOSS);
+            {
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS);
+                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_PARTIAL_LOSS));
+            }
+            await backtest$1.strategyCoreService.partialLoss(false, symbol, percentToClose, currentPrice, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                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.
          *
@@ -17690,7 +19412,11 @@ class LiveUtils {
          * ```
          */
         this.getData = async (symbol, context) => {
-            backtest$1.strategyValidationService.validate(context.strategyName, "LiveUtils.getData");
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_DATA, {
+                symbol,
+                context,
+            });
+            backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA);
@@ -17718,6 +19444,10 @@ class LiveUtils {
          * ```
          */
         this.getReport = async (symbol, context, columns) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_REPORT, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17753,6 +19483,11 @@ class LiveUtils {
          * ```
          */
         this.dump = async (symbol, context, path, columns) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_DUMP, {
+                symbol,
+                context,
+                path,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -18099,6 +19834,7 @@ const INSTANCE_TASK_FN = async (symbol, context, self) => {
         await doneWalkerSubject.next({
             exchangeName: walkerSchema.exchangeName,
             strategyName: context.walkerName,
+            frameName: walkerSchema.frameName,
             backtest: true,
             symbol,
         });
@@ -18289,6 +20025,7 @@ class WalkerInstance {
                     doneWalkerSubject.next({
                         exchangeName: walkerSchema.exchangeName,
                         strategyName: context.walkerName,
+                        frameName: walkerSchema.frameName,
                         backtest: true,
                         symbol,
                     });
@@ -18397,18 +20134,22 @@ class WalkerUtils {
          * Stop signal is filtered by walkerName to prevent interference.
          *
          * @param symbol - Trading pair symbol
-         * @param walkerName - Walker name to stop
+         * @param context - Execution context with walker name
          * @returns Promise that resolves when all stop flags are set
          *
          * @example
          * ```typescript
          * // Stop walker and all its strategies
-         * await Walker.stop("BTCUSDT", "my-walker");
+         * await Walker.stop("BTCUSDT", { walkerName: "my-walker" });
          * ```
          */
-        this.stop = async (symbol, walkerName) => {
-            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_STOP);
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+        this.stop = async (symbol, context) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_STOP, {
+                symbol,
+                context,
+            });
+            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_STOP);
+            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_STOP);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -18418,7 +20159,7 @@ class WalkerUtils {
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP));
             }
             for (const strategyName of walkerSchema.strategies) {
-                await walkerStopSubject.next({ symbol, strategyName, walkerName });
+                await walkerStopSubject.next({ symbol, strategyName, walkerName: context.walkerName });
                 await backtest$1.strategyCoreService.stop(true, symbol, {
                     strategyName,
                     exchangeName: walkerSchema.exchangeName,
@@ -18430,18 +20171,22 @@ class WalkerUtils {
          * Gets walker results data from all strategy comparisons.
          *
          * @param symbol - Trading symbol
-         * @param walkerName - Walker name to get data for
+         * @param context - Execution context with walker name
          * @returns Promise resolving to walker results data object
          *
          * @example
          * ```typescript
-         * const results = await Walker.getData("BTCUSDT", "my-walker");
+         * const results = await Walker.getData("BTCUSDT", { walkerName: "my-walker" });
          * console.log(results.bestStrategy, results.bestMetric);
          * ```
          */
-        this.getData = async (symbol, walkerName) => {
-            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_GET_DATA);
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+        this.getData = async (symbol, context) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_DATA, {
+                symbol,
+                context,
+            });
+            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_GET_DATA);
+            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_DATA);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -18450,7 +20195,7 @@ class WalkerUtils {
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA));
             }
-            return await backtest$1.walkerMarkdownService.getData(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+            return await backtest$1.walkerMarkdownService.getData(context.walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
             });
@@ -18459,20 +20204,24 @@ class WalkerUtils {
          * Generates markdown report with all strategy comparisons for a walker.
          *
          * @param symbol - Trading symbol
-         * @param walkerName - Walker name to generate report for
+         * @param context - Execution context with walker name
          * @param strategyColumns - Optional strategy columns configuration
          * @param pnlColumns - Optional PNL columns configuration
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
          * ```typescript
-         * const markdown = await Walker.getReport("BTCUSDT", "my-walker");
+         * const markdown = await Walker.getReport("BTCUSDT", { walkerName: "my-walker" });
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, walkerName, strategyColumns, pnlColumns) => {
-            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_GET_REPORT);
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+        this.getReport = async (symbol, context, strategyColumns, pnlColumns) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_REPORT, {
+                symbol,
+                context,
+            });
+            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_GET_REPORT);
+            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_REPORT);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -18481,7 +20230,7 @@ class WalkerUtils {
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.walkerMarkdownService.getReport(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+            return await backtest$1.walkerMarkdownService.getReport(context.walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
             }, strategyColumns, pnlColumns);
@@ -18490,7 +20239,7 @@ class WalkerUtils {
          * Saves walker report to disk.
          *
          * @param symbol - Trading symbol
-         * @param walkerName - Walker name to save report for
+         * @param context - Execution context with walker name
          * @param path - Optional directory path to save report (default: "./dump/walker")
          * @param strategyColumns - Optional strategy columns configuration
          * @param pnlColumns - Optional PNL columns configuration
@@ -18498,15 +20247,20 @@ class WalkerUtils {
          * @example
          * ```typescript
          * // Save to default path: ./dump/walker/my-walker.md
-         * await Walker.dump("BTCUSDT", "my-walker");
+         * await Walker.dump("BTCUSDT", { walkerName: "my-walker" });
          *
          * // Save to custom path: ./custom/path/my-walker.md
-         * await Walker.dump("BTCUSDT", "my-walker", "./custom/path");
+         * await Walker.dump("BTCUSDT", { walkerName: "my-walker" }, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, walkerName, path, strategyColumns, pnlColumns) => {
-            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_DUMP);
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+        this.dump = async (symbol, context, path, strategyColumns, pnlColumns) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_DUMP, {
+                symbol,
+                context,
+                path,
+            });
+            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_DUMP);
+            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_DUMP);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -18515,7 +20269,7 @@ class WalkerUtils {
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP));
             }
-            await backtest$1.walkerMarkdownService.dump(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+            await backtest$1.walkerMarkdownService.dump(context.walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
             }, path, strategyColumns, pnlColumns);
@@ -20335,8 +22089,11 @@ exports.listenWalker = listenWalker;
 exports.listenWalkerComplete = listenWalkerComplete;
 exports.listenWalkerOnce = listenWalkerOnce;
 exports.listenWalkerProgress = listenWalkerProgress;
+exports.partialLoss = partialLoss;
+exports.partialProfit = partialProfit;
 exports.setColumns = setColumns;
 exports.setConfig = setConfig;
 exports.setLogger = setLogger;
 exports.stop = stop;
+exports.trailingStop = trailingStop;
 exports.validate = validate;