backtest-kit 1.7.2 → 1.9.1

package/build/index.mjs

@@ -1,6 +1,6 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, isObject, ToolRegistry, and, resolveDocuments, str, iterateDocuments, distinctDocuments, queued, singlerun } from 'functools-kit';
+import { Subject, trycatch, errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, retry, randomString, isObject, ToolRegistry, and, resolveDocuments, str, iterateDocuments, distinctDocuments, compose, queued, singlerun } from 'functools-kit';
 import fs, { mkdir, writeFile } from 'fs/promises';
 import path, { join } from 'path';
 import crypto from 'crypto';
@@ -361,6 +361,136 @@ const GLOBAL_CONFIG = {
 };
 const DEFAULT_CONFIG = Object.freeze({ ...GLOBAL_CONFIG });
 
+/**
+ * Global signal emitter for all trading events (live + backtest).
+ * Emits all signal events regardless of execution mode.
+ */
+const signalEmitter = new Subject();
+/**
+ * Live trading signal emitter.
+ * Emits only signals from live trading execution.
+ */
+const signalLiveEmitter = new Subject();
+/**
+ * Backtest signal emitter.
+ * Emits only signals from backtest execution.
+ */
+const signalBacktestEmitter = new Subject();
+/**
+ * Error emitter for background execution errors.
+ * Emits errors caught in background tasks (Live.background, Backtest.background).
+ */
+const errorEmitter = new Subject();
+/**
+ * Exit emitter for critical errors that require process termination.
+ * Emits errors that should terminate the current execution (Backtest, Live, Walker).
+ * Unlike errorEmitter (for recoverable errors), exitEmitter signals fatal errors.
+ */
+const exitEmitter = new Subject();
+/**
+ * Done emitter for live background execution completion.
+ * Emits when live background tasks complete (Live.background).
+ */
+const doneLiveSubject = new Subject();
+/**
+ * Done emitter for backtest background execution completion.
+ * Emits when backtest background tasks complete (Backtest.background).
+ */
+const doneBacktestSubject = new Subject();
+/**
+ * Done emitter for walker background execution completion.
+ * Emits when walker background tasks complete (Walker.background).
+ */
+const doneWalkerSubject = new Subject();
+/**
+ * Progress emitter for backtest execution progress.
+ * Emits progress updates during backtest execution.
+ */
+const progressBacktestEmitter = new Subject();
+/**
+ * Progress emitter for walker execution progress.
+ * Emits progress updates during walker execution.
+ */
+const progressWalkerEmitter = new Subject();
+/**
+ * Progress emitter for optimizer execution progress.
+ * Emits progress updates during optimizer execution.
+ */
+const progressOptimizerEmitter = new Subject();
+/**
+ * Performance emitter for execution metrics.
+ * Emits performance metrics for profiling and bottleneck detection.
+ */
+const performanceEmitter = new Subject();
+/**
+ * Walker emitter for strategy comparison progress.
+ * Emits progress updates during walker execution (each strategy completion).
+ */
+const walkerEmitter = new Subject();
+/**
+ * Walker complete emitter for strategy comparison completion.
+ * Emits when all strategies have been tested and final results are available.
+ */
+const walkerCompleteSubject = new Subject();
+/**
+ * Walker stop emitter for walker cancellation events.
+ * Emits when a walker comparison is stopped/cancelled.
+ *
+ * Includes walkerName to support multiple walkers running on the same symbol.
+ */
+const walkerStopSubject = new Subject();
+/**
+ * Validation emitter for risk validation errors.
+ * Emits when risk validation functions throw errors during signal checking.
+ */
+const validationSubject = new Subject();
+/**
+ * Partial profit emitter for profit level milestones.
+ * Emits when a signal reaches a profit level (10%, 20%, 30%, etc).
+ */
+const partialProfitSubject = new Subject();
+/**
+ * Partial loss emitter for loss level milestones.
+ * Emits when a signal reaches a loss level (10%, 20%, 30%, etc).
+ */
+const partialLossSubject = new Subject();
+/**
+ * Risk rejection emitter for risk management violations.
+ * Emits ONLY when a signal is rejected due to risk validation failure.
+ * Does not emit for allowed signals (prevents spam).
+ */
+const riskSubject = new Subject();
+/**
+ * Ping emitter for scheduled signal monitoring events.
+ * Emits every minute when a scheduled signal is being monitored (waiting for activation).
+ * Allows users to track scheduled signal lifecycle and implement custom cancellation logic.
+ */
+const pingSubject = new Subject();
+
+var emitters = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    doneBacktestSubject: doneBacktestSubject,
+    doneLiveSubject: doneLiveSubject,
+    doneWalkerSubject: doneWalkerSubject,
+    errorEmitter: errorEmitter,
+    exitEmitter: exitEmitter,
+    partialLossSubject: partialLossSubject,
+    partialProfitSubject: partialProfitSubject,
+    performanceEmitter: performanceEmitter,
+    pingSubject: pingSubject,
+    progressBacktestEmitter: progressBacktestEmitter,
+    progressOptimizerEmitter: progressOptimizerEmitter,
+    progressWalkerEmitter: progressWalkerEmitter,
+    riskSubject: riskSubject,
+    signalBacktestEmitter: signalBacktestEmitter,
+    signalEmitter: signalEmitter,
+    signalLiveEmitter: signalLiveEmitter,
+    validationSubject: validationSubject,
+    walkerCompleteSubject: walkerCompleteSubject,
+    walkerEmitter: walkerEmitter,
+    walkerStopSubject: walkerStopSubject
+});
+
 const INTERVAL_MINUTES$4 = {
     "1m": 1,
     "3m": 3,
@@ -462,6 +592,33 @@ const GET_CANDLES_FN = async (dto, since, self) => {
     }
     throw lastError;
 };
+/**
+ * Wrapper to call onCandleData callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param self - ClientExchange instance reference
+ * @param symbol - Trading pair symbol
+ * @param interval - Candle interval
+ * @param since - Start date for candle data
+ * @param limit - Number of candles
+ * @param data - Array of candle data
+ */
+const CALL_CANDLE_DATA_CALLBACKS_FN = trycatch(async (self, symbol, interval, since, limit, data) => {
+    if (self.params.callbacks?.onCandleData) {
+        await self.params.callbacks.onCandleData(symbol, interval, since, limit, data);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientExchange CALL_CANDLE_DATA_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Client implementation for exchange data access.
  *
@@ -520,9 +677,7 @@ class ClientExchange {
         if (filteredData.length < limit) {
             this.params.logger.warn(`ClientExchange Expected ${limit} candles, got ${filteredData.length}`);
         }
-        if (this.params.callbacks?.onCandleData) {
-            this.params.callbacks.onCandleData(symbol, interval, since, limit, filteredData);
-        }
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, filteredData);
         return filteredData;
     }
     /**
@@ -557,9 +712,7 @@ class ClientExchange {
         if (filteredData.length < limit) {
             this.params.logger.warn(`ClientExchange getNextCandles: Expected ${limit} candles, got ${filteredData.length}`);
         }
-        if (this.params.callbacks?.onCandleData) {
-            this.params.callbacks.onCandleData(symbol, interval, since, limit, filteredData);
-        }
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, filteredData);
         return filteredData;
     }
     /**
@@ -770,6 +923,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)
@@ -777,27 +935,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") {
@@ -1646,412 +1890,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 Subject();
-/**
- * Live trading signal emitter.
- * Emits only signals from live trading execution.
- */
-const signalLiveEmitter = new Subject();
-/**
- * Backtest signal emitter.
- * Emits only signals from backtest execution.
+ * Converts markdown content to plain text with minimal formatting
+ * @param content - Markdown string to convert
+ * @returns Plain text representation
  */
-const signalBacktestEmitter = new 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 Subject();
-/**
- * Exit emitter for critical errors that require process termination.
- * Emits errors that should terminate the current execution (Backtest, Live, Walker).
- * Unlike errorEmitter (for recoverable errors), exitEmitter signals fatal errors.
- */
-const exitEmitter = new Subject();
-/**
- * Done emitter for live background execution completion.
- * Emits when live background tasks complete (Live.background).
- */
-const doneLiveSubject = new Subject();
-/**
- * Done emitter for backtest background execution completion.
- * Emits when backtest background tasks complete (Backtest.background).
- */
-const doneBacktestSubject = new Subject();
-/**
- * Done emitter for walker background execution completion.
- * Emits when walker background tasks complete (Walker.background).
- */
-const doneWalkerSubject = new Subject();
-/**
- * Progress emitter for backtest execution progress.
- * Emits progress updates during backtest execution.
- */
-const progressBacktestEmitter = new Subject();
-/**
- * Progress emitter for walker execution progress.
- * Emits progress updates during walker execution.
- */
-const progressWalkerEmitter = new Subject();
-/**
- * Progress emitter for optimizer execution progress.
- * Emits progress updates during optimizer execution.
- */
-const progressOptimizerEmitter = new Subject();
-/**
- * Performance emitter for execution metrics.
- * Emits performance metrics for profiling and bottleneck detection.
- */
-const performanceEmitter = new Subject();
-/**
- * Walker emitter for strategy comparison progress.
- * Emits progress updates during walker execution (each strategy completion).
- */
-const walkerEmitter = new Subject();
-/**
- * Walker complete emitter for strategy comparison completion.
- * Emits when all strategies have been tested and final results are available.
- */
-const walkerCompleteSubject = new Subject();
-/**
- * Walker stop emitter for walker cancellation events.
- * Emits when a walker comparison is stopped/cancelled.
- *
- * Includes walkerName to support multiple walkers running on the same symbol.
- */
-const walkerStopSubject = new Subject();
-/**
- * Validation emitter for risk validation errors.
- * Emits when risk validation functions throw errors during signal checking.
- */
-const validationSubject = new Subject();
-/**
- * Partial profit emitter for profit level milestones.
- * Emits when a signal reaches a profit level (10%, 20%, 30%, etc).
- */
-const partialProfitSubject = new Subject();
-/**
- * Partial loss emitter for loss level milestones.
- * Emits when a signal reaches a loss level (10%, 20%, 30%, etc).
- */
-const partialLossSubject = new Subject();
-/**
- * Risk rejection emitter for risk management violations.
- * Emits ONLY when a signal is rejected due to risk validation failure.
- * Does not emit for allowed signals (prevents spam).
- */
-const riskSubject = new Subject();
-/**
- * Ping emitter for scheduled signal monitoring events.
- * Emits every minute when a scheduled signal is being monitored (waiting for activation).
- * Allows users to track scheduled signal lifecycle and implement custom cancellation logic.
- */
-const pingSubject = new Subject();
-
-var emitters = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    doneBacktestSubject: doneBacktestSubject,
-    doneLiveSubject: doneLiveSubject,
-    doneWalkerSubject: doneWalkerSubject,
-    errorEmitter: errorEmitter,
-    exitEmitter: exitEmitter,
-    partialLossSubject: partialLossSubject,
-    partialProfitSubject: partialProfitSubject,
-    performanceEmitter: performanceEmitter,
-    pingSubject: pingSubject,
-    progressBacktestEmitter: progressBacktestEmitter,
-    progressOptimizerEmitter: progressOptimizerEmitter,
-    progressWalkerEmitter: progressWalkerEmitter,
-    riskSubject: riskSubject,
-    signalBacktestEmitter: signalBacktestEmitter,
-    signalEmitter: signalEmitter,
-    signalLiveEmitter: signalLiveEmitter,
-    validationSubject: validationSubject,
-    walkerCompleteSubject: walkerCompleteSubject,
-    walkerEmitter: walkerEmitter,
-    walkerStopSubject: walkerStopSubject
-});
-
-/**
- * Converts markdown content to plain text with minimal formatting
- * @param content - Markdown string to convert
- * @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) {
@@ -2088,15 +2296,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
     if (self._isStopped) {
         return null;
     }
-    if (await 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 not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest))) {
         return null;
     }
     // Если priceOpen указан - проверяем нужно ли ждать активации или открыть сразу
@@ -2205,10 +2405,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);
@@ -2221,10 +2420,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) => {
@@ -2242,12 +2605,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,
@@ -2257,9 +2618,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) => {
@@ -2300,14 +2659,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,
@@ -2315,9 +2673,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) => {
@@ -2344,15 +2700,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
         scheduledAt: scheduled.scheduledAt,
         pendingAt: activationTime,
     });
-    if (await 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 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,
@@ -2368,18 +2716,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,
@@ -2387,18 +2728,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 = 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 = 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";
@@ -2411,11 +2757,319 @@ const CALL_PING_CALLBACKS_FN = trycatch(async (self, scheduled, timestamp) => {
         errorEmitter.next(error);
     },
 });
+const CALL_ACTIVE_CALLBACKS_FN = 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_SCHEDULE_CALLBACKS_FN = 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_CANCEL_CALLBACKS_FN = 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_OPEN_CALLBACKS_FN = 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_CLOSE_CALLBACKS_FN = 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_TICK_CALLBACKS_FN = 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_IDLE_CALLBACKS_FN = 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_RISK_ADD_SIGNAL_FN = 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_RISK_REMOVE_SIGNAL_FN = 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_PARTIAL_CLEAR_FN = 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_RISK_CHECK_SIGNAL_FN = 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_PARTIAL_PROFIT_CALLBACKS_FN = 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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_PARTIAL_LOSS_CALLBACKS_FN = 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: errorData(error),
+            message: 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,
@@ -2425,13 +3079,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,
@@ -2439,12 +3092,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,
@@ -2452,35 +3103,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 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 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,
@@ -2488,9 +3123,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) => {
@@ -2511,19 +3144,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,
@@ -2531,24 +3166,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,
@@ -2556,14 +3184,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") {
@@ -2574,20 +3201,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") {
@@ -2598,26 +3220,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,
@@ -2627,15 +3244,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,
@@ -2646,9 +3260,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) => {
@@ -2661,12 +3273,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,
@@ -2676,9 +3286,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) => {
@@ -2702,15 +3310,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
         scheduledAt: scheduled.scheduledAt,
         pendingAt: activationTime,
     });
-    if (await 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 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,
@@ -2726,15 +3326,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) => {
@@ -2753,21 +3346,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,
@@ -2778,9 +3364,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) => {
@@ -2855,7 +3439,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,
@@ -2893,13 +3477,15 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         }
         // Check TP/SL only if not expired
         // КРИТИЧНО: используем candle.high/low для точной проверки достижения TP/SL
+        // КРИТИЧНО: используем trailing SL если установлен
+        const effectiveStopLoss = signal._trailingPriceStopLoss ?? signal.priceStopLoss;
         if (!shouldClose && signal.position === "long") {
             // Для LONG: TP срабатывает если high >= TP, SL если low <= SL
             if (currentCandle.high >= signal.priceTakeProfit) {
                 shouldClose = true;
                 closeReason = "take_profit";
             }
-            else if (currentCandle.low <= signal.priceStopLoss) {
+            else if (currentCandle.low <= effectiveStopLoss) {
                 shouldClose = true;
                 closeReason = "stop_loss";
             }
@@ -2910,7 +3496,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                 shouldClose = true;
                 closeReason = "take_profit";
             }
-            else if (currentCandle.high >= signal.priceStopLoss) {
+            else if (currentCandle.high >= effectiveStopLoss) {
                 shouldClose = true;
                 closeReason = "stop_loss";
             }
@@ -2922,7 +3508,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                 closePrice = signal.priceTakeProfit;
             }
             else if (closeReason === "stop_loss") {
-                closePrice = signal.priceStopLoss;
+                closePrice = effectiveStopLoss; // Используем trailing SL если установлен
             }
             return await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(self, signal, closePrice, closeReason, currentCandleTimestamp);
         }
@@ -2936,19 +3522,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") {
@@ -2958,19 +3539,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);
                 }
             }
         }
@@ -3040,7 +3616,8 @@ class ClientStrategy {
         // КРИТИЧНО: Всегда вызываем коллбек onWrite для тестирования persist storage
         // даже в backtest режиме, чтобы тесты могли перехватывать вызовы через mock adapter
         if (this.params.callbacks?.onWrite) {
-            this.params.callbacks.onWrite(this.params.execution.context.symbol, this._pendingSignal, this.params.execution.context.backtest);
+            const publicSignal = this._pendingSignal ? TO_PUBLIC_SIGNAL(this._pendingSignal) : null;
+            this.params.callbacks.onWrite(this.params.execution.context.symbol, publicSignal, this.params.execution.context.backtest);
         }
         if (this.params.execution.context.backtest) {
             return;
@@ -3075,7 +3652,7 @@ class ClientStrategy {
         this.params.logger.debug("ClientStrategy getPendingSignal", {
             symbol,
         });
-        return this._pendingSignal;
+        return this._pendingSignal ? TO_PUBLIC_SIGNAL(this._pendingSignal) : null;
     }
     /**
      * Retrieves the current scheduled signal.
@@ -3086,7 +3663,7 @@ class ClientStrategy {
         this.params.logger.debug("ClientStrategy getScheduledSignal", {
             symbol,
         });
-        return this._scheduledSignal;
+        return this._scheduledSignal ? TO_PUBLIC_SIGNAL(this._scheduledSignal) : null;
     }
     /**
      * Returns the stopped state of the strategy.
@@ -3156,12 +3733,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,
@@ -3270,14 +3845,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,
@@ -3337,7 +3911,7 @@ class ClientStrategy {
                     // but this is correct behavior if someone calls backtest() with partial data
                     const result = {
                         action: "active",
-                        signal: scheduled,
+                        signal: TO_PUBLIC_SIGNAL(scheduled),
                         currentPrice: lastPrice,
                         percentSl: 0,
                         percentTp: 0,
@@ -3456,6 +4030,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";
@@ -3857,6 +4698,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);
@@ -3880,7 +4722,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,
@@ -4082,6 +4924,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);
+        };
     }
 }
 
@@ -4104,6 +5058,32 @@ const INTERVAL_MINUTES$2 = {
     "1d": 1440,
     "3d": 4320,
 };
+/**
+ * Wrapper to call onTimeframe callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param self - ClientFrame instance reference
+ * @param timeframe - Array of generated timestamp dates
+ * @param startDate - Start date of the backtest period
+ * @param endDate - Effective end date of the backtest period
+ * @param interval - Frame interval used for generation
+ */
+const CALL_TIMEFRAME_CALLBACKS_FN = trycatch(async (self, timeframe, startDate, endDate, interval) => {
+    if (self.params.callbacks?.onTimeframe) {
+        await self.params.callbacks.onTimeframe(timeframe, startDate, endDate, interval);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientFrame CALL_TIMEFRAME_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Generates timeframe array from startDate to endDate with specified interval.
  * Uses prototype function pattern for memory efficiency.
@@ -4133,9 +5113,7 @@ const GET_TIMEFRAME_FN = async (symbol, self) => {
         timeframes.push(new Date(currentDate));
         currentDate = new Date(currentDate.getTime() + intervalMinutes * 60 * 1000);
     }
-    if (self.params.callbacks?.onTimeframe) {
-        self.params.callbacks.onTimeframe(timeframes, startDate, effectiveEndDate, interval);
-    }
+    await CALL_TIMEFRAME_CALLBACKS_FN(self, timeframes, startDate, effectiveEndDate, interval);
     return timeframes;
 };
 /**
@@ -4294,6 +5272,30 @@ const calculateATRBased = (params, schema) => {
     const stopDistance = atr * atrMultiplier;
     return riskAmount / stopDistance;
 };
+/**
+ * Wrapper to call onCalculate callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param self - ClientSizing instance reference
+ * @param quantity - Calculated position size
+ * @param params - Parameters used for size calculation
+ */
+const CALL_CALCULATE_CALLBACKS_FN = trycatch(async (self, quantity, params) => {
+    if (self.params.callbacks?.onCalculate) {
+        await self.params.callbacks.onCalculate(quantity, params);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientSizing CALL_CALCULATE_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Main calculation function routing to specific sizing method.
  * Applies min/max constraints after calculation.
@@ -4347,9 +5349,7 @@ const CALCULATE_FN = async (params, self) => {
         quantity = Math.min(quantity, schema.maxPositionSize);
     }
     // Trigger callback if defined
-    if (schema.callbacks?.onCalculate) {
-        schema.callbacks.onCalculate(quantity, params);
-    }
+    await CALL_CALCULATE_CALLBACKS_FN(self, quantity, params);
     return quantity;
 };
 /**
@@ -4465,6 +5465,50 @@ const get = (object, path) => {
 
 /** Symbol indicating that positions need to be fetched from persistence */
 const POSITION_NEED_FETCH = Symbol("risk-need-fetch");
+/**
+ * Converts signal to risk validation format.
+ *
+ * This function is used BEFORE position opens during risk checks.
+ * It ensures all required fields are present for risk validation:
+ *
+ * - Falls back to currentPrice if priceOpen is not set (for ISignalDto/scheduled signals)
+ * - Replaces priceStopLoss with trailing SL if active (for positions with trailing stops)
+ * - Preserves original stop-loss in originalPriceStopLoss for reference
+ *
+ * Use cases:
+ * - Risk validation before opening a position (checkSignal)
+ * - Pre-flight validation of scheduled signals
+ * - Calculating position size based on stop-loss distance
+ *
+ * @param signal - Signal DTO or row (may not have priceOpen for scheduled signals)
+ * @param currentPrice - Current market price, used as fallback for priceOpen if not set
+ * @returns Signal in IRiskSignalRow format with guaranteed priceOpen and effective stop-loss
+ *
+ * @example
+ * ```typescript
+ * // For scheduled signal without priceOpen
+ * const riskSignal = TO_RISK_SIGNAL(scheduledSignal, 45000);
+ * // riskSignal.priceOpen = 45000 (fallback to currentPrice)
+ *
+ * // For signal with trailing SL
+ * const riskSignal = TO_RISK_SIGNAL(activeSignal, 46000);
+ * // riskSignal.priceStopLoss = activeSignal._trailingPriceStopLoss
+ * ```
+ */
+const TO_RISK_SIGNAL = (signal, currentPrice) => {
+    if ("_trailingPriceStopLoss" in signal) {
+        return {
+            ...signal,
+            priceStopLoss: signal._trailingPriceStopLoss,
+            originalPriceStopLoss: signal.priceStopLoss,
+        };
+    }
+    return {
+        ...signal,
+        priceOpen: signal.priceOpen ?? currentPrice,
+        originalPriceStopLoss: signal.priceStopLoss,
+    };
+};
 /** Key generator for active position map */
 const CREATE_NAME_FN = (strategyName, exchangeName, symbol) => `${strategyName}_${exchangeName}_${symbol}`;
 /** Wrapper to execute risk validation function with error handling */
@@ -4484,7 +5528,41 @@ const DO_VALIDATION_FN = async (validation, params) => {
         return payload.message;
     }
 };
-/**
+/** Wrapper to call onRejected callback with error handling */
+const CALL_REJECTED_CALLBACKS_FN = trycatch(async (self, symbol, params) => {
+    if (self.params.callbacks?.onRejected) {
+        await self.params.callbacks.onRejected(symbol, params);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientRisk CALL_REJECTED_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/** Wrapper to call onAllowed callback with error handling */
+const CALL_ALLOWED_CALLBACKS_FN = trycatch(async (self, symbol, params) => {
+    if (self.params.callbacks?.onAllowed) {
+        await self.params.callbacks.onAllowed(symbol, params);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientRisk CALL_ALLOWED_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
  * Initializes active positions by reading from persistence.
  * Uses singleshot pattern to ensure it only runs once.
  * This function is exported for use in tests or other modules.
@@ -4554,6 +5632,7 @@ class ClientRisk {
             const riskMap = this._activePositions;
             const payload = {
                 ...params,
+                pendingSignal: TO_RISK_SIGNAL(params.pendingSignal, params.currentPrice),
                 activePositionCount: riskMap.size,
                 activePositions: Array.from(riskMap.values()),
             };
@@ -4588,15 +5667,11 @@ class ClientRisk {
                 // Call params.onRejected for riskSubject emission
                 await this.params.onRejected(params.symbol, params, riskMap.size, rejectionResult, params.timestamp, this.params.backtest);
                 // Call schema callbacks.onRejected if defined
-                if (this.params.callbacks?.onRejected) {
-                    this.params.callbacks.onRejected(params.symbol, params);
-                }
+                await CALL_REJECTED_CALLBACKS_FN(this, params.symbol, params);
                 return false;
             }
             // All checks passed
-            if (this.params.callbacks?.onAllowed) {
-                this.params.callbacks.onAllowed(params.symbol, params);
-            }
+            await CALL_ALLOWED_CALLBACKS_FN(this, params.symbol, params);
             return true;
         };
     }
@@ -5208,6 +6283,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);
+        };
     }
 }
 
@@ -6348,6 +7535,104 @@ class LiveLogicPrivateService {
     }
 }
 
+/**
+ * Wrapper to call onStrategyStart callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param walkerSchema - Walker schema containing callbacks
+ * @param strategyName - Name of the strategy being tested
+ * @param symbol - Trading pair symbol
+ */
+const CALL_STRATEGY_START_CALLBACKS_FN = trycatch(async (walkerSchema, strategyName, symbol) => {
+    if (walkerSchema.callbacks?.onStrategyStart) {
+        await walkerSchema.callbacks.onStrategyStart(strategyName, symbol);
+    }
+}, {
+    fallback: (error) => {
+        const message = "WalkerLogicPrivateService CALL_STRATEGY_START_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Wrapper to call onStrategyError callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param walkerSchema - Walker schema containing callbacks
+ * @param strategyName - Name of the strategy that failed
+ * @param symbol - Trading pair symbol
+ * @param error - Error that occurred during strategy execution
+ */
+const CALL_STRATEGY_ERROR_CALLBACKS_FN = trycatch(async (walkerSchema, strategyName, symbol, error) => {
+    if (walkerSchema.callbacks?.onStrategyError) {
+        await walkerSchema.callbacks.onStrategyError(strategyName, symbol, error);
+    }
+}, {
+    fallback: (error) => {
+        const message = "WalkerLogicPrivateService CALL_STRATEGY_ERROR_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Wrapper to call onStrategyComplete callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param walkerSchema - Walker schema containing callbacks
+ * @param strategyName - Name of the strategy that completed
+ * @param symbol - Trading pair symbol
+ * @param stats - Backtest statistics for the strategy
+ * @param metricValue - Calculated metric value for comparison
+ */
+const CALL_STRATEGY_COMPLETE_CALLBACKS_FN = trycatch(async (walkerSchema, strategyName, symbol, stats, metricValue) => {
+    if (walkerSchema.callbacks?.onStrategyComplete) {
+        await walkerSchema.callbacks.onStrategyComplete(strategyName, symbol, stats, metricValue);
+    }
+}, {
+    fallback: (error) => {
+        const message = "WalkerLogicPrivateService CALL_STRATEGY_COMPLETE_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Wrapper to call onComplete callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param walkerSchema - Walker schema containing callbacks
+ * @param finalResults - Final results with all strategies ranked
+ */
+const CALL_COMPLETE_CALLBACKS_FN = trycatch(async (walkerSchema, finalResults) => {
+    if (walkerSchema.callbacks?.onComplete) {
+        await walkerSchema.callbacks.onComplete(finalResults);
+    }
+}, {
+    fallback: (error) => {
+        const message = "WalkerLogicPrivateService CALL_COMPLETE_CALLBACKS_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Private service for walker orchestration (strategy comparison).
  *
@@ -6433,9 +7718,7 @@ class WalkerLogicPrivateService {
                     break;
                 }
                 // Call onStrategyStart callback if provided
-                if (walkerSchema.callbacks?.onStrategyStart) {
-                    walkerSchema.callbacks.onStrategyStart(strategyName, symbol);
-                }
+                await CALL_STRATEGY_START_CALLBACKS_FN(walkerSchema, strategyName, symbol);
                 this.loggerService.info("walkerLogicPrivateService testing strategy", {
                     strategyName,
                     symbol,
@@ -6457,9 +7740,7 @@ class WalkerLogicPrivateService {
                     });
                     await errorEmitter.next(error);
                     // Call onStrategyError callback if provided
-                    if (walkerSchema.callbacks?.onStrategyError) {
-                        walkerSchema.callbacks.onStrategyError(strategyName, symbol, error);
-                    }
+                    await CALL_STRATEGY_ERROR_CALLBACKS_FN(walkerSchema, strategyName, symbol, error);
                     continue;
                 }
                 this.loggerService.info("walkerLogicPrivateService backtest complete", {
@@ -6510,9 +7791,7 @@ class WalkerLogicPrivateService {
                     progress: strategies.length > 0 ? strategiesTested / strategies.length : 0,
                 });
                 // Call onStrategyComplete callback if provided
-                if (walkerSchema.callbacks?.onStrategyComplete) {
-                    await walkerSchema.callbacks.onStrategyComplete(strategyName, symbol, stats, metricValue);
-                }
+                await CALL_STRATEGY_COMPLETE_CALLBACKS_FN(walkerSchema, strategyName, symbol, stats, metricValue);
                 await walkerEmitter.next(walkerContract);
                 yield walkerContract;
             }
@@ -6535,9 +7814,7 @@ class WalkerLogicPrivateService {
                 : null,
         };
         // Call onComplete callback if provided with final best results
-        if (walkerSchema.callbacks?.onComplete) {
-            walkerSchema.callbacks.onComplete(finalResults);
-        }
+        await CALL_COMPLETE_CALLBACKS_FN(walkerSchema, finalResults);
         await walkerCompleteSubject.next(finalResults);
     }
 }
@@ -6930,6 +8207,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",
@@ -7005,49 +8297,49 @@ const heat_columns = [
     {
         key: "totalPnl",
         label: "Total PNL",
-        format: (data) => data.totalPnl !== null ? str(data.totalPnl, "%+.2f%%") : "N/A",
+        format: (data) => data.totalPnl !== null ? str(data.totalPnl, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "sharpeRatio",
         label: "Sharpe",
-        format: (data) => data.sharpeRatio !== null ? str(data.sharpeRatio, "%.2f") : "N/A",
+        format: (data) => data.sharpeRatio !== null ? str(data.sharpeRatio) : "N/A",
         isVisible: () => true,
     },
     {
         key: "profitFactor",
         label: "PF",
-        format: (data) => data.profitFactor !== null ? str(data.profitFactor, "%.2f") : "N/A",
+        format: (data) => data.profitFactor !== null ? str(data.profitFactor) : "N/A",
         isVisible: () => true,
     },
     {
         key: "expectancy",
         label: "Expect",
-        format: (data) => data.expectancy !== null ? str(data.expectancy, "%+.2f%%") : "N/A",
+        format: (data) => data.expectancy !== null ? str(data.expectancy, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "winRate",
         label: "WR",
-        format: (data) => data.winRate !== null ? str(data.winRate, "%.1f%%") : "N/A",
+        format: (data) => data.winRate !== null ? str(data.winRate, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "avgWin",
         label: "Avg Win",
-        format: (data) => data.avgWin !== null ? str(data.avgWin, "%+.2f%%") : "N/A",
+        format: (data) => data.avgWin !== null ? str(data.avgWin, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "avgLoss",
         label: "Avg Loss",
-        format: (data) => data.avgLoss !== null ? str(data.avgLoss, "%+.2f%%") : "N/A",
+        format: (data) => data.avgLoss !== null ? str(data.avgLoss, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "maxDrawdown",
         label: "Max DD",
-        format: (data) => data.maxDrawdown !== null ? str(-data.maxDrawdown, "%.2f%%") : "N/A",
+        format: (data) => data.maxDrawdown !== null ? str(-data.maxDrawdown, "%") : "N/A",
         isVisible: () => true,
     },
     {
@@ -8285,7 +9577,7 @@ class BacktestMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("backtestMarkdownService init");
-            signalBacktestEmitter.subscribe(this.tick);
+            this.unsubscribe = signalBacktestEmitter.subscribe(this.tick);
         });
     }
 }
@@ -8814,7 +10106,7 @@ class LiveMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("liveMarkdownService init");
-            signalLiveEmitter.subscribe(this.tick);
+            this.unsubscribe = signalLiveEmitter.subscribe(this.tick);
         });
     }
 }
@@ -9243,7 +10535,7 @@ class ScheduleMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("scheduleMarkdownService init");
-            signalEmitter.subscribe(this.tick);
+            this.unsubscribe = signalEmitter.subscribe(this.tick);
         });
     }
 }
@@ -9611,7 +10903,7 @@ class PerformanceMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("performanceMarkdownService init");
-            performanceEmitter.subscribe(this.track);
+            this.unsubscribe = performanceEmitter.subscribe(this.track);
         });
     }
 }
@@ -10020,7 +11312,7 @@ class WalkerMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("walkerMarkdownService init");
-            walkerEmitter.subscribe(this.tick);
+            this.unsubscribe = walkerEmitter.subscribe(this.tick);
         });
     }
 }
@@ -10322,7 +11614,7 @@ class HeatmapStorage {
         return [
             `# Portfolio Heatmap: ${strategyName}`,
             "",
-            `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? str(data.portfolioTotalPnl, "%+.2f%%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? str(data.portfolioSharpeRatio, "%.2f") : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades}`,
+            `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? str(data.portfolioTotalPnl, "%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? str(data.portfolioSharpeRatio) : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades}`,
             "",
             table
         ].join("\n");
@@ -10547,7 +11839,7 @@ class HeatMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("heatMarkdownService init");
-            signalEmitter.subscribe(this.tick);
+            this.unsubscribe = signalEmitter.subscribe(this.tick);
         });
     }
 }
@@ -11426,12 +12718,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) => {`,
@@ -11465,12 +12761,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) {`,
@@ -11486,7 +12780,7 @@ class OptimizerTemplateService {
                 `            systemMessages.forEach((msg, idx) => {`,
                 `                summary += \`### System Message \${idx + 1}\\n\\n\`;`,
                 `                summary += msg.content;`,
-                `                summary += "\\n";`,
+                `                summary += "\\n\\n";`,
                 `            });`,
                 `        }`,
                 ``,
@@ -13309,8 +14603,9 @@ class PartialMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("partialMarkdownService init");
-            partialProfitSubject.subscribe(this.tickProfit);
-            partialLossSubject.subscribe(this.tickLoss);
+            const unProfit = partialProfitSubject.subscribe(this.tickProfit);
+            const unLoss = partialLossSubject.subscribe(this.tickLoss);
+            this.unsubscribe = compose(() => unProfit(), () => unLoss());
         });
     }
 }
@@ -14055,7 +15350,7 @@ class RiskMarkdownService {
          */
         this.init = singleshot(async () => {
             this.loggerService.log("riskMarkdownService init");
-            riskSubject.subscribe(this.tickRejection);
+            this.unsubscribe = riskSubject.subscribe(this.tickRejection);
         });
     }
 }
@@ -14510,95 +15805,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 });
 }
 
 /**
@@ -16316,224 +17918,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";
@@ -16623,6 +18037,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.
@@ -16649,6 +18066,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,
         });
@@ -16870,6 +18288,7 @@ class BacktestInstance {
                         await doneBacktestSubject.next({
                             exchangeName: context.exchangeName,
                             strategyName: context.strategyName,
+                            frameName: context.frameName,
                             backtest: true,
                             symbol,
                         });
@@ -16982,6 +18401,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);
@@ -17009,6 +18432,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);
@@ -17042,6 +18469,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);
@@ -17076,6 +18507,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);
@@ -17086,6 +18522,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.
          *
@@ -17105,6 +18665,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);
@@ -17135,6 +18699,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);
@@ -17172,6 +18740,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);
@@ -17232,6 +18805,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.
@@ -17257,6 +18833,7 @@ const INSTANCE_TASK_FN$1 = async (symbol, context, self) => {
         await doneLiveSubject.next({
             exchangeName: context.exchangeName,
             strategyName: context.strategyName,
+            frameName: "",
             backtest: false,
             symbol,
         });
@@ -17443,6 +19020,7 @@ class LiveInstance {
                         await doneLiveSubject.next({
                             exchangeName: context.exchangeName,
                             strategyName: context.strategyName,
+                            frameName: "",
                             backtest: false,
                             symbol,
                         });
@@ -17562,6 +19140,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);
@@ -17591,6 +19173,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);
@@ -17621,6 +19207,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);
@@ -17657,6 +19247,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);
@@ -17669,6 +19264,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.
          *
@@ -17688,7 +19410,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);
@@ -17716,6 +19442,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);
@@ -17751,6 +19481,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);
@@ -18097,6 +19832,7 @@ const INSTANCE_TASK_FN = async (symbol, context, self) => {
         await doneWalkerSubject.next({
             exchangeName: walkerSchema.exchangeName,
             strategyName: context.walkerName,
+            frameName: walkerSchema.frameName,
             backtest: true,
             symbol,
         });
@@ -18287,6 +20023,7 @@ class WalkerInstance {
                     doneWalkerSubject.next({
                         exchangeName: walkerSchema.exchangeName,
                         strategyName: context.walkerName,
+                        frameName: walkerSchema.frameName,
                         backtest: true,
                         symbol,
                     });
@@ -18395,18 +20132,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);
@@ -18416,7 +20157,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,
@@ -18428,18 +20169,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);
@@ -18448,7 +20193,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,
             });
@@ -18457,20 +20202,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);
@@ -18479,7 +20228,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);
@@ -18488,7 +20237,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
@@ -18496,15 +20245,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);
@@ -18513,7 +20267,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);
@@ -20253,4 +22007,4 @@ class NotificationUtils {
  */
 const Notification = new NotificationUtils();
 
-export { Backtest, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, cancel, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getColumns, getConfig, getDate, getDefaultColumns, getDefaultConfig, getMode, hasTradeContext, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenPing, listenPingOnce, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setColumns, setConfig, setLogger, stop, validate };
+export { Backtest, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, cancel, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getColumns, getConfig, getDate, getDefaultColumns, getDefaultConfig, getMode, hasTradeContext, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenPing, listenPingOnce, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, partialLoss, partialProfit, setColumns, setConfig, setLogger, stop, trailingStop, validate };