backtest-kit 1.7.2 → 1.8.1

package/build/index.cjs

@@ -772,6 +772,11 @@ class ExchangeConnectionService {
 /**
  * Calculates profit/loss for a closed signal with slippage and fees.
  *
+ * For signals with partial closes:
+ * - Calculates weighted PNL: Σ(percent_i × pnl_i) for each partial + (remaining% × final_pnl)
+ * - Each partial close has its own fees and slippage
+ * - Total fees = 2 × (number of partial closes + 1 final close) × CC_PERCENT_FEE
+ *
  * Formula breakdown:
  * 1. Apply slippage to open/close prices (worse execution)
  *    - LONG: buy higher (+slippage), sell lower (-slippage)
@@ -779,27 +784,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") {
@@ -2090,15 +2181,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
     if (self._isStopped) {
         return null;
     }
-    if (await functoolsKit.not(self.params.risk.checkSignal({
-        pendingSignal: signal,
-        symbol: self.params.execution.context.symbol,
-        strategyName: self.params.method.context.strategyName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-        currentPrice,
-        timestamp: currentTime,
-    }))) {
+    if (await functoolsKit.not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, signal, currentPrice, currentTime, self.params.execution.context.backtest))) {
         return null;
     }
     // Если priceOpen указан - проверяем нужно ли ждать активации или открыть сразу
@@ -2207,10 +2290,9 @@ const WAIT_FOR_INIT_FN$2 = async (self) => {
         }
         self._pendingSignal = pendingSignal;
         // Call onActive callback for restored signal
-        if (self.params.callbacks?.onActive) {
-            const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
-            self.params.callbacks.onActive(self.params.execution.context.symbol, pendingSignal, currentPrice, self.params.execution.context.backtest);
-        }
+        const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
+        const currentTime = self.params.execution.context.when.getTime();
+        await CALL_ACTIVE_CALLBACKS_FN(self, self.params.execution.context.symbol, pendingSignal, currentPrice, currentTime, self.params.execution.context.backtest);
     }
     // Restore scheduled signal
     const scheduledSignal = await PersistScheduleAdapter.readScheduleData(self.params.execution.context.symbol, self.params.strategyName);
@@ -2223,11 +2305,84 @@ 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 CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN = async (self, scheduled, currentPrice) => {
     const currentTime = self.params.execution.context.when.getTime();
@@ -2244,9 +2399,7 @@ 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,
@@ -2259,9 +2412,7 @@ const CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN = async (self, scheduled, currentPrice)
         backtest: self.params.execution.context.backtest,
         reason: "timeout",
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const CHECK_SCHEDULED_SIGNAL_PRICE_ACTIVATION_FN = (scheduled, currentPrice) => {
@@ -2302,14 +2453,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,
         currentPrice: currentPrice,
-        closeTimestamp: self.params.execution.context.when.getTime(),
+        closeTimestamp: currentTime,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
         frameName: self.params.method.context.frameName,
@@ -2317,9 +2467,7 @@ const CANCEL_SCHEDULED_SIGNAL_BY_STOPLOSS_FN = async (self, scheduled, currentPr
         backtest: self.params.execution.context.backtest,
         reason: "price_reject",
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp) => {
@@ -2346,15 +2494,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
         scheduledAt: scheduled.scheduledAt,
         pendingAt: activationTime,
     });
-    if (await functoolsKit.not(self.params.risk.checkSignal({
-        symbol: self.params.execution.context.symbol,
-        pendingSignal: scheduled,
-        strategyName: self.params.method.context.strategyName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-        currentPrice: scheduled.priceOpen,
-        timestamp: activationTime,
-    }))) {
+    if (await functoolsKit.not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, scheduled, scheduled.priceOpen, activationTime, self.params.execution.context.backtest))) {
         self.params.logger.info("ClientStrategy scheduled signal rejected by risk", {
             symbol: self.params.execution.context.symbol,
             signalId: scheduled.id,
@@ -2370,15 +2510,8 @@ 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,
@@ -2389,18 +2522,22 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
         currentPrice: self._pendingSignal.priceOpen,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, activationTime, self.params.execution.context.backtest);
     return result;
 };
-const CALL_PING_CALLBACKS_FN = functoolsKit.trycatch(async (self, scheduled, timestamp) => {
-    // Call system onPing callback first (emits to pingSubject)
-    await self.params.onPing(self.params.execution.context.symbol, self.params.method.context.strategyName, self.params.method.context.exchangeName, scheduled, self.params.execution.context.backtest, timestamp);
-    // Call user onPing callback only if signal is still active (not cancelled, not activated)
-    if (self.params.callbacks?.onPing) {
-        await self.params.callbacks.onPing(self.params.execution.context.symbol, scheduled, new Date(timestamp), self.params.execution.context.backtest);
-    }
+const CALL_PING_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, scheduled, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        // 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);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
 }, {
     fallback: (error) => {
         const message = "ClientStrategy CALL_PING_CALLBACKS_FN thrown";
@@ -2413,8 +2550,308 @@ const CALL_PING_CALLBACKS_FN = functoolsKit.trycatch(async (self, scheduled, tim
         errorEmitter.next(error);
     },
 });
+const CALL_ACTIVE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (self.params.callbacks?.onActive) {
+            self.params.callbacks.onActive(self.params.execution.context.symbol, signal, currentPrice, self.params.execution.context.backtest);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_ACTIVE_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_SCHEDULE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (self.params.callbacks?.onSchedule) {
+            self.params.callbacks.onSchedule(self.params.execution.context.symbol, signal, currentPrice, self.params.execution.context.backtest);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_SCHEDULE_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_CANCEL_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (self.params.callbacks?.onCancel) {
+            self.params.callbacks.onCancel(self.params.execution.context.symbol, signal, currentPrice, self.params.execution.context.backtest);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_CANCEL_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_OPEN_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, priceOpen, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (self.params.callbacks?.onOpen) {
+            self.params.callbacks.onOpen(self.params.execution.context.symbol, signal, priceOpen, self.params.execution.context.backtest);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_OPEN_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_CLOSE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (self.params.callbacks?.onClose) {
+            self.params.callbacks.onClose(self.params.execution.context.symbol, signal, currentPrice, self.params.execution.context.backtest);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_CLOSE_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_TICK_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, result, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (self.params.callbacks?.onTick) {
+            self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_TICK_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_IDLE_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, currentPrice, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        if (self.params.callbacks?.onIdle) {
+            self.params.callbacks.onIdle(self.params.execution.context.symbol, currentPrice, self.params.execution.context.backtest);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_IDLE_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_RISK_ADD_SIGNAL_FN = functoolsKit.trycatch(async (self, symbol, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        await self.params.risk.addSignal(symbol, {
+            strategyName: self.params.method.context.strategyName,
+            riskName: self.params.riskName,
+            exchangeName: self.params.method.context.exchangeName,
+            frameName: self.params.method.context.frameName,
+        });
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_RISK_ADD_SIGNAL_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_RISK_REMOVE_SIGNAL_FN = functoolsKit.trycatch(async (self, symbol, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        await self.params.risk.removeSignal(symbol, {
+            strategyName: self.params.method.context.strategyName,
+            riskName: self.params.riskName,
+            exchangeName: self.params.method.context.exchangeName,
+            frameName: self.params.method.context.frameName,
+        });
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_RISK_REMOVE_SIGNAL_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_PARTIAL_CLEAR_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        await self.params.partial.clear(symbol, signal, currentPrice, backtest);
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_PARTIAL_CLEAR_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_RISK_CHECK_SIGNAL_FN = functoolsKit.trycatch(async (self, symbol, pendingSignal, currentPrice, timestamp, backtest) => {
+    return await ExecutionContextService.runInContext(async () => {
+        return await self.params.risk.checkSignal({
+            pendingSignal,
+            symbol: symbol,
+            strategyName: self.params.method.context.strategyName,
+            exchangeName: self.params.method.context.exchangeName,
+            frameName: self.params.method.context.frameName,
+            currentPrice,
+            timestamp,
+        });
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    defaultValue: false,
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_RISK_CHECK_SIGNAL_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_PARTIAL_PROFIT_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, percentTp, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        await self.params.partial.profit(symbol, signal, currentPrice, percentTp, backtest, new Date(timestamp));
+        if (self.params.callbacks?.onPartialProfit) {
+            self.params.callbacks.onPartialProfit(symbol, signal, currentPrice, percentTp, backtest);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_PARTIAL_PROFIT_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+const CALL_PARTIAL_LOSS_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, signal, currentPrice, percentSl, timestamp, backtest) => {
+    await ExecutionContextService.runInContext(async () => {
+        await self.params.partial.loss(symbol, signal, currentPrice, percentSl, backtest, new Date(timestamp));
+        if (self.params.callbacks?.onPartialLoss) {
+            self.params.callbacks.onPartialLoss(symbol, signal, currentPrice, percentSl, backtest);
+        }
+    }, {
+        when: new Date(timestamp),
+        symbol: symbol,
+        backtest: backtest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_PARTIAL_LOSS_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
 const RETURN_SCHEDULED_SIGNAL_ACTIVE_FN = async (self, scheduled, currentPrice) => {
-    await CALL_PING_CALLBACKS_FN(self, scheduled, self.params.execution.context.when.getTime());
+    const currentTime = self.params.execution.context.when.getTime();
+    await CALL_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "active",
         signal: scheduled,
@@ -2427,13 +2864,12 @@ const RETURN_SCHEDULED_SIGNAL_ACTIVE_FN = async (self, scheduled, currentPrice)
         percentSl: 0,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const OPEN_NEW_SCHEDULED_SIGNAL_FN = async (self, signal) => {
     const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
+    const currentTime = self.params.execution.context.when.getTime();
     self.params.logger.info("ClientStrategy scheduled signal created", {
         symbol: self.params.execution.context.symbol,
         signalId: signal.id,
@@ -2441,9 +2877,7 @@ 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,
@@ -2454,32 +2888,16 @@ const OPEN_NEW_SCHEDULED_SIGNAL_FN = async (self, signal) => {
         currentPrice: currentPrice,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const OPEN_NEW_PENDING_SIGNAL_FN = async (self, signal) => {
-    if (await functoolsKit.not(self.params.risk.checkSignal({
-        pendingSignal: signal,
-        symbol: self.params.execution.context.symbol,
-        strategyName: self.params.method.context.strategyName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-        currentPrice: signal.priceOpen,
-        timestamp: self.params.execution.context.when.getTime(),
-    }))) {
+    const currentTime = self.params.execution.context.when.getTime();
+    if (await functoolsKit.not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, signal, signal.priceOpen, currentTime, self.params.execution.context.backtest))) {
         return null;
     }
-    await self.params.risk.addSignal(self.params.execution.context.symbol, {
-        strategyName: self.params.method.context.strategyName,
-        riskName: self.params.riskName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-    });
-    if (self.params.callbacks?.onOpen) {
-        self.params.callbacks.onOpen(self.params.execution.context.symbol, signal, signal.priceOpen, self.params.execution.context.backtest);
-    }
+    await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, currentTime, self.params.execution.context.backtest);
+    await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, signal.priceOpen, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "opened",
         signal: signal,
@@ -2490,9 +2908,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) => {
@@ -2526,6 +2942,7 @@ const CHECK_PENDING_SIGNAL_COMPLETION_FN = async (self, signal, averagePrice) =>
 };
 const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason) => {
     const pnl = toProfitLossDto(signal, currentPrice);
+    const currentTime = self.params.execution.context.when.getTime();
     self.params.logger.info(`ClientStrategy signal ${closeReason}`, {
         symbol: self.params.execution.context.symbol,
         signalId: signal.id,
@@ -2533,24 +2950,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,
         currentPrice: currentPrice,
         closeReason: closeReason,
-        closeTimestamp: self.params.execution.context.when.getTime(),
+        closeTimestamp: currentTime,
         pnl: pnl,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
@@ -2558,14 +2968,13 @@ const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason)
         symbol: self.params.execution.context.symbol,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
     let percentTp = 0;
     let percentSl = 0;
+    const currentTime = self.params.execution.context.when.getTime();
     // Calculate percentage of path to TP/SL for partial fill/loss callbacks
     {
         if (signal.position === "long") {
@@ -2576,20 +2985,14 @@ 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;
                 const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
                 percentSl = Math.min(progressPercent, 100);
-                await self.params.partial.loss(self.params.execution.context.symbol, signal, currentPrice, percentSl, self.params.execution.context.backtest, self.params.execution.context.when);
-                if (self.params.callbacks?.onPartialLoss) {
-                    self.params.callbacks.onPartialLoss(self.params.execution.context.symbol, signal, currentPrice, percentSl, self.params.execution.context.backtest);
-                }
+                await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentSl, currentTime, self.params.execution.context.backtest);
             }
         }
         else if (signal.position === "short") {
@@ -2600,20 +3003,14 @@ 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;
                 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);
             }
         }
     }
@@ -2629,15 +3026,12 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
         percentSl,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const RETURN_IDLE_FN = async (self, currentPrice) => {
-    if (self.params.callbacks?.onIdle) {
-        self.params.callbacks.onIdle(self.params.execution.context.symbol, currentPrice, self.params.execution.context.backtest);
-    }
+    const currentTime = self.params.execution.context.when.getTime();
+    await CALL_IDLE_CALLBACKS_FN(self, self.params.execution.context.symbol, currentPrice, currentTime, self.params.execution.context.backtest);
     const result = {
         action: "idle",
         signal: null,
@@ -2648,9 +3042,7 @@ const RETURN_IDLE_FN = async (self, currentPrice) => {
         currentPrice: currentPrice,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, currentTime, self.params.execution.context.backtest);
     return result;
 };
 const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePrice, closeTimestamp, reason) => {
@@ -2663,9 +3055,7 @@ 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,
@@ -2678,9 +3068,7 @@ const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePr
         backtest: self.params.execution.context.backtest,
         reason,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
     return result;
 };
 const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activationTimestamp) => {
@@ -2704,15 +3092,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
         scheduledAt: scheduled.scheduledAt,
         pendingAt: activationTime,
     });
-    if (await functoolsKit.not(self.params.risk.checkSignal({
-        pendingSignal: scheduled,
-        symbol: self.params.execution.context.symbol,
-        strategyName: self.params.method.context.strategyName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-        currentPrice: scheduled.priceOpen,
-        timestamp: activationTime,
-    }))) {
+    if (await functoolsKit.not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, scheduled, scheduled.priceOpen, activationTime, self.params.execution.context.backtest))) {
         self.params.logger.info("ClientStrategy backtest scheduled signal rejected by risk", {
             symbol: self.params.execution.context.symbol,
             signalId: scheduled.id,
@@ -2728,15 +3108,8 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
         _isScheduled: false,
     };
     await self.setPendingSignal(activatedSignal);
-    await self.params.risk.addSignal(self.params.execution.context.symbol, {
-        strategyName: self.params.method.context.strategyName,
-        riskName: self.params.riskName,
-        exchangeName: self.params.method.context.exchangeName,
-        frameName: self.params.method.context.frameName,
-    });
-    if (self.params.callbacks?.onOpen) {
-        self.params.callbacks.onOpen(self.params.execution.context.symbol, activatedSignal, activatedSignal.priceOpen, self.params.execution.context.backtest);
-    }
+    await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, activationTime, self.params.execution.context.backtest);
+    await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, activatedSignal, activatedSignal.priceOpen, activationTime, self.params.execution.context.backtest);
     return true;
 };
 const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, closeReason, closeTimestamp) => {
@@ -2755,17 +3128,10 @@ 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",
@@ -2780,9 +3146,7 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
         symbol: self.params.execution.context.symbol,
         backtest: self.params.execution.context.backtest,
     };
-    if (self.params.callbacks?.onTick) {
-        self.params.callbacks.onTick(self.params.execution.context.symbol, result, self.params.execution.context.backtest);
-    }
+    await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
     return result;
 };
 const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) => {
@@ -2857,7 +3221,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,
@@ -2938,19 +3302,13 @@ 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;
                     const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
-                    await self.params.partial.loss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, new Date(currentCandleTimestamp));
-                    if (self.params.callbacks?.onPartialLoss) {
-                        self.params.callbacks.onPartialLoss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest);
-                    }
+                    await CALL_PARTIAL_LOSS_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), currentCandleTimestamp, self.params.execution.context.backtest);
                 }
             }
             else if (signal.position === "short") {
@@ -2960,19 +3318,13 @@ 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;
                     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);
                 }
             }
         }
@@ -3158,9 +3510,7 @@ 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,
@@ -3272,14 +3622,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,
                 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,
@@ -3458,6 +3807,190 @@ 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, 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, this._pendingSignal, backtest);
+        }
+        if (!backtest) {
+            await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName);
+        }
+    }
 }
 
 const RISK_METHOD_NAME_GET_DATA = "RiskUtils.getData";
@@ -3859,6 +4392,7 @@ class StrategyConnectionService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.executionContextService = inject(TYPES.executionContextService);
+        this.methodContextService = inject(TYPES.methodContextService);
         this.strategySchemaService = inject(TYPES.strategySchemaService);
         this.riskConnectionService = inject(TYPES.riskConnectionService);
         this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
@@ -3882,7 +4416,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,
@@ -4061,28 +4595,104 @@ class StrategyConnectionService {
             }
         };
         /**
-         * Cancels the scheduled signal for the specified strategy.
+         * Cancels the scheduled signal for the specified strategy.
+         *
+         * Delegates to ClientStrategy.cancel() which clears the scheduled signal
+         * without stopping the strategy or affecting pending signals.
+         *
+         * Note: Cancelled event will be emitted on next tick() call when strategy
+         * detects the scheduled signal was cancelled.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param ctx - Context with strategyName, exchangeName, frameName
+         * @param cancelId - Optional cancellation ID for user-initiated cancellations
+         * @returns Promise that resolves when scheduled signal is cancelled
+         */
+        this.cancel = async (backtest, symbol, context, cancelId) => {
+            this.loggerService.log("strategyConnectionService cancel", {
+                symbol,
+                context,
+                cancelId,
+            });
+            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).
          *
-         * Delegates to ClientStrategy.cancel() which clears the scheduled signal
-         * without stopping the strategy or affecting pending signals.
+         * 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.
          *
-         * Note: Cancelled event will be emitted on next tick() call when strategy
-         * detects the scheduled signal was cancelled.
+         * Delegates to ClientStrategy.partialLoss() with current execution context.
          *
          * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
-         * @param ctx - Context with strategyName, exchangeName, frameName
-         * @param cancelId - Optional cancellation ID for user-initiated cancellations
-         * @returns Promise that resolves when scheduled signal is cancelled
+         * @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.cancel = async (backtest, symbol, context, cancelId) => {
-            this.loggerService.log("strategyConnectionService cancel", {
+        this.partialLoss = async (backtest, symbol, percentToClose, currentPrice, context) => {
+            this.loggerService.log("strategyConnectionService partialLoss", {
                 symbol,
                 context,
-                cancelId,
+                percentToClose,
+                currentPrice,
+                backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.cancel(symbol, backtest, cancelId);
+            await strategy.partialLoss(symbol, percentToClose, currentPrice, backtest);
         };
     }
 }
@@ -5210,6 +5820,82 @@ 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);
+        };
     }
 }
 
@@ -6932,6 +7618,21 @@ const backtest_columns = [
         },
         isVisible: () => true,
     },
+    {
+        key: "partialCloses",
+        label: "Partial Closes",
+        format: (data) => {
+            const partial = data.signal._partial;
+            if (!partial || partial.length === 0)
+                return "N/A";
+            const profitCount = partial.filter(p => p.type === "profit").length;
+            const lossCount = partial.filter(p => p.type === "loss").length;
+            const profitPercent = partial.filter(p => p.type === "profit").reduce((sum, p) => sum + p.percent, 0);
+            const lossPercent = partial.filter(p => p.type === "loss").reduce((sum, p) => sum + p.percent, 0);
+            return `${partial.length} (↑${profitCount}: ${profitPercent.toFixed(1)}%, ↓${lossCount}: ${lossPercent.toFixed(1)}%)`;
+        },
+        isVisible: () => true,
+    },
     {
         key: "closeReason",
         label: "Close Reason",
@@ -7007,49 +7708,49 @@ const heat_columns = [
     {
         key: "totalPnl",
         label: "Total PNL",
-        format: (data) => data.totalPnl !== null ? functoolsKit.str(data.totalPnl, "%+.2f%%") : "N/A",
+        format: (data) => data.totalPnl !== null ? functoolsKit.str(data.totalPnl, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "sharpeRatio",
         label: "Sharpe",
-        format: (data) => data.sharpeRatio !== null ? functoolsKit.str(data.sharpeRatio, "%.2f") : "N/A",
+        format: (data) => data.sharpeRatio !== null ? functoolsKit.str(data.sharpeRatio) : "N/A",
         isVisible: () => true,
     },
     {
         key: "profitFactor",
         label: "PF",
-        format: (data) => data.profitFactor !== null ? functoolsKit.str(data.profitFactor, "%.2f") : "N/A",
+        format: (data) => data.profitFactor !== null ? functoolsKit.str(data.profitFactor) : "N/A",
         isVisible: () => true,
     },
     {
         key: "expectancy",
         label: "Expect",
-        format: (data) => data.expectancy !== null ? functoolsKit.str(data.expectancy, "%+.2f%%") : "N/A",
+        format: (data) => data.expectancy !== null ? functoolsKit.str(data.expectancy, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "winRate",
         label: "WR",
-        format: (data) => data.winRate !== null ? functoolsKit.str(data.winRate, "%.1f%%") : "N/A",
+        format: (data) => data.winRate !== null ? functoolsKit.str(data.winRate, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "avgWin",
         label: "Avg Win",
-        format: (data) => data.avgWin !== null ? functoolsKit.str(data.avgWin, "%+.2f%%") : "N/A",
+        format: (data) => data.avgWin !== null ? functoolsKit.str(data.avgWin, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "avgLoss",
         label: "Avg Loss",
-        format: (data) => data.avgLoss !== null ? functoolsKit.str(data.avgLoss, "%+.2f%%") : "N/A",
+        format: (data) => data.avgLoss !== null ? functoolsKit.str(data.avgLoss, "%") : "N/A",
         isVisible: () => true,
     },
     {
         key: "maxDrawdown",
         label: "Max DD",
-        format: (data) => data.maxDrawdown !== null ? functoolsKit.str(-data.maxDrawdown, "%.2f%%") : "N/A",
+        format: (data) => data.maxDrawdown !== null ? functoolsKit.str(-data.maxDrawdown, "%") : "N/A",
         isVisible: () => true,
     },
     {
@@ -10324,7 +11025,7 @@ class HeatmapStorage {
         return [
             `# Portfolio Heatmap: ${strategyName}`,
             "",
-            `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? functoolsKit.str(data.portfolioTotalPnl, "%+.2f%%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? functoolsKit.str(data.portfolioSharpeRatio, "%.2f") : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades}`,
+            `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? functoolsKit.str(data.portfolioTotalPnl, "%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? functoolsKit.str(data.portfolioSharpeRatio) : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades}`,
             "",
             table
         ].join("\n");
@@ -11428,12 +12129,16 @@ class OptimizerTemplateService {
                 ``,
                 `listenWalkerComplete((results) => {`,
                 `    console.log("Walker completed:", results.bestStrategy);`,
-                `    Walker.dump("${escapedSymbol}", results.walkerName);`,
+                `    Walker.dump(results.symbol, { walkerName: results.walkerName });`,
                 `});`,
                 ``,
                 `listenDoneBacktest((event) => {`,
                 `    console.log("Backtest completed:", event.symbol);`,
-                `    Backtest.dump(event.symbol, event.strategyName);`,
+                `    Backtest.dump(event.symbol, {`,
+                `        strategyName: event.strategyName,`,
+                `        exchangeName: event.exchangeName,`,
+                `        frameName: event.frameName`,
+                `    });`,
                 `});`,
                 ``,
                 `listenError((error) => {`,
@@ -11467,12 +12172,10 @@ class OptimizerTemplateService {
                 `    }`,
                 ``,
                 `    {`,
-                `        let summary = "# Outline Result Summary\\n";`,
+                `        let summary = "# Outline Result Summary\\n\\n";`,
                 ``,
                 `        {`,
-                `            summary += "\\n";`,
-                `            summary += \`**ResultId**: \${resultId}\\n\`;`,
-                `            summary += "\\n";`,
+                `            summary += \`**ResultId**: \${resultId}\\n\\n\`;`,
                 `        }`,
                 ``,
                 `        if (result) {`,
@@ -11488,7 +12191,7 @@ class OptimizerTemplateService {
                 `            systemMessages.forEach((msg, idx) => {`,
                 `                summary += \`### System Message \${idx + 1}\\n\\n\`;`,
                 `                summary += msg.content;`,
-                `                summary += "\\n";`,
+                `                summary += "\\n\\n";`,
                 `            });`,
                 `        }`,
                 ``,
@@ -14519,13 +15222,203 @@ const validateInternal = async (args) => {
  * });
  * ```
  */
-async function validate(args = {}) {
-    backtest$1.loggerService.log(METHOD_NAME);
-    return await validateInternal(args);
+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";
 /**
  * Stops the strategy from generating new signals.
  *
@@ -14602,6 +15495,86 @@ async function cancel(symbol, cancelId) {
     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 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 });
+}
+/**
+ * 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).
+ *
+ * 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 loss direction:
+ *   - LONG: currentPrice must be < priceOpen
+ *   - SHORT: currentPrice must be > priceOpen
+ *
+ * @example
+ * ```typescript
+ * import { partialLoss } from "backtest-kit";
+ *
+ * // Close 40% of LONG position at loss
+ * await partialLoss("BTCUSDT", 40, 38000);
+ * ```
+ */
+async function partialLoss(symbol, percentToClose) {
+    backtest$1.loggerService.info(PARTIAL_LOSS_METHOD_NAME, {
+        symbol,
+        percentToClose,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("partialLoss requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        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.partialLoss(isBacktest, symbol, percentToClose, currentPrice, { exchangeName, frameName, strategyName });
+}
 
 /**
  * Sets custom logger implementation for the framework.
@@ -16284,258 +17257,70 @@ function listenRisk(fn) {
  * cancel();
  * ```
  */
-function listenRiskOnce(filterFn, fn) {
-    backtest$1.loggerService.log(LISTEN_RISK_ONCE_METHOD_NAME);
-    return riskSubject.filter(filterFn).once(fn);
-}
-/**
- * Subscribes to ping events during scheduled signal monitoring with queued async processing.
- *
- * Events are emitted every minute when a scheduled signal is being monitored (waiting for activation).
- * Allows tracking of scheduled signal lifecycle and custom monitoring logic.
- *
- * @param fn - Callback function to handle ping events
- * @returns Unsubscribe function to stop listening
- *
- * @example
- * ```typescript
- * import { listenPing } from "./function/event";
- *
- * const unsubscribe = listenPing((event) => {
- *   console.log(`Ping for ${event.symbol} at ${new Date(event.timestamp).toISOString()}`);
- *   console.log(`Strategy: ${event.strategyName}, Exchange: ${event.exchangeName}`);
- *   console.log(`Mode: ${event.backtest ? "Backtest" : "Live"}`);
- * });
- *
- * // Later: stop listening
- * unsubscribe();
- * ```
- */
-function listenPing(fn) {
-    backtest$1.loggerService.log(LISTEN_PING_METHOD_NAME);
-    return pingSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
-}
-/**
- * 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);
+function listenRiskOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_RISK_ONCE_METHOD_NAME);
+    return riskSubject.filter(filterFn).once(fn);
 }
 /**
- * Gets the current date from execution context.
+ * Subscribes to ping events during scheduled signal monitoring with queued async processing.
  *
- * In backtest mode: returns the current timeframe date being processed
- * In live mode: returns current real-time date
+ * Events are emitted every minute when a scheduled signal is being monitored (waiting for activation).
+ * Allows tracking of scheduled signal lifecycle and custom monitoring logic.
  *
- * @returns Promise resolving to current execution context date
+ * @param fn - Callback function to handle ping events
+ * @returns Unsubscribe function to stop listening
  *
  * @example
  * ```typescript
- * const date = await getDate();
- * console.log(date); // 2024-01-01T12:00:00.000Z
+ * import { listenPing } from "./function/event";
+ *
+ * const unsubscribe = listenPing((event) => {
+ *   console.log(`Ping for ${event.symbol} at ${new Date(event.timestamp).toISOString()}`);
+ *   console.log(`Strategy: ${event.strategyName}, Exchange: ${event.exchangeName}`);
+ *   console.log(`Mode: ${event.backtest ? "Backtest" : "Live"}`);
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
  * ```
  */
-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());
+function listenPing(fn) {
+    backtest$1.loggerService.log(LISTEN_PING_METHOD_NAME);
+    return pingSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
 }
 /**
- * Gets the current execution mode.
+ * Subscribes to filtered ping events with one-time execution.
  *
- * @returns Promise resolving to "backtest" or "live"
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific ping conditions.
+ *
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @returns Unsubscribe function to cancel the listener before it fires
  *
  * @example
  * ```typescript
- * const mode = await getMode();
- * if (mode === "backtest") {
- *   console.log("Running in backtest mode");
- * } else {
- *   console.log("Running in live mode");
- * }
+ * import { listenPingOnce } from "./function/event";
+ *
+ * // Wait for first ping on BTCUSDT
+ * listenPingOnce(
+ *   (event) => event.symbol === "BTCUSDT",
+ *   (event) => console.log("First BTCUSDT ping received")
+ * );
+ *
+ * // Wait for ping in backtest mode
+ * const cancel = listenPingOnce(
+ *   (event) => event.backtest === true,
+ *   (event) => console.log("Backtest ping received at", new Date(event.timestamp))
+ * );
+ *
+ * // Cancel if needed before event fires
+ * cancel();
  * ```
  */
-async function getMode() {
-    backtest$1.loggerService.info(GET_MODE_METHOD_NAME);
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("getMode requires an execution context");
-    }
-    const { backtest: bt } = backtest$1.executionContextService.context;
-    return bt ? "backtest" : "live";
+function listenPingOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_PING_ONCE_METHOD_NAME);
+    return pingSubject.filter(filterFn).once(fn);
 }
 
 const DUMP_SIGNAL_METHOD_NAME = "dump.dumpSignal";
@@ -16625,6 +17410,8 @@ 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_GET_DATA = "BacktestUtils.getData";
 /**
  * Internal task function that runs backtest and handles completion.
@@ -16651,6 +17438,7 @@ const INSTANCE_TASK_FN$2 = async (symbol, context, self) => {
         await doneBacktestSubject.next({
             exchangeName: context.exchangeName,
             strategyName: context.strategyName,
+            frameName: context.frameName,
             backtest: true,
             symbol,
         });
@@ -16872,6 +17660,7 @@ class BacktestInstance {
                         await doneBacktestSubject.next({
                             exchangeName: context.exchangeName,
                             strategyName: context.strategyName,
+                            frameName: context.frameName,
                             backtest: true,
                             symbol,
                         });
@@ -16984,6 +17773,10 @@ class BacktestUtils {
          * ```
          */
         this.getPendingSignal = async (symbol, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17011,6 +17804,10 @@ class BacktestUtils {
          * ```
          */
         this.getScheduledSignal = async (symbol, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17044,6 +17841,10 @@ class BacktestUtils {
          * ```
          */
         this.stop = async (symbol, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_STOP, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_STOP);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17078,6 +17879,11 @@ class BacktestUtils {
          * ```
          */
         this.cancel = async (symbol, context, cancelId) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_CANCEL, {
+                symbol,
+                context,
+                cancelId,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CANCEL);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17088,6 +17894,92 @@ 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);
+        };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
          *
@@ -17107,6 +17999,10 @@ class BacktestUtils {
          * ```
          */
         this.getData = async (symbol, context) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_DATA, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17137,6 +18033,10 @@ class BacktestUtils {
          * ```
          */
         this.getReport = async (symbol, context, columns) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_REPORT, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17174,6 +18074,11 @@ class BacktestUtils {
          * ```
          */
         this.dump = async (symbol, context, path, columns) => {
+            backtest$1.loggerService.info(BACKTEST_METHOD_NAME_DUMP, {
+                symbol,
+                context,
+                path,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17234,6 +18139,8 @@ 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";
 /**
  * Internal task function that runs live trading and handles completion.
  * Consumes live trading results and updates instance state flags.
@@ -17259,6 +18166,7 @@ const INSTANCE_TASK_FN$1 = async (symbol, context, self) => {
         await doneLiveSubject.next({
             exchangeName: context.exchangeName,
             strategyName: context.strategyName,
+            frameName: "",
             backtest: false,
             symbol,
         });
@@ -17445,6 +18353,7 @@ class LiveInstance {
                         await doneLiveSubject.next({
                             exchangeName: context.exchangeName,
                             strategyName: context.strategyName,
+                            frameName: "",
                             backtest: false,
                             symbol,
                         });
@@ -17564,6 +18473,10 @@ class LiveUtils {
          * ```
          */
         this.getPendingSignal = async (symbol, context) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_PENDING_SIGNAL, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17593,6 +18506,10 @@ class LiveUtils {
          * ```
          */
         this.getScheduledSignal = async (symbol, context) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17623,6 +18540,10 @@ class LiveUtils {
          * ```
          */
         this.stop = async (symbol, context) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_STOP, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_STOP);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17659,6 +18580,11 @@ class LiveUtils {
          * ```
          */
         this.cancel = async (symbol, context, cancelId) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_CANCEL, {
+                symbol,
+                context,
+                cancelId,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CANCEL);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17671,6 +18597,94 @@ 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: "",
+            });
+        };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
          *
@@ -17690,7 +18704,11 @@ class LiveUtils {
          * ```
          */
         this.getData = async (symbol, context) => {
-            backtest$1.strategyValidationService.validate(context.strategyName, "LiveUtils.getData");
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_DATA, {
+                symbol,
+                context,
+            });
+            backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_DATA);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA);
@@ -17718,6 +18736,10 @@ class LiveUtils {
          * ```
          */
         this.getReport = async (symbol, context, columns) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_REPORT, {
+                symbol,
+                context,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -17753,6 +18775,11 @@ class LiveUtils {
          * ```
          */
         this.dump = async (symbol, context, path, columns) => {
+            backtest$1.loggerService.info(LIVE_METHOD_NAME_DUMP, {
+                symbol,
+                context,
+                path,
+            });
             backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -18099,6 +19126,7 @@ const INSTANCE_TASK_FN = async (symbol, context, self) => {
         await doneWalkerSubject.next({
             exchangeName: walkerSchema.exchangeName,
             strategyName: context.walkerName,
+            frameName: walkerSchema.frameName,
             backtest: true,
             symbol,
         });
@@ -18289,6 +19317,7 @@ class WalkerInstance {
                     doneWalkerSubject.next({
                         exchangeName: walkerSchema.exchangeName,
                         strategyName: context.walkerName,
+                        frameName: walkerSchema.frameName,
                         backtest: true,
                         symbol,
                     });
@@ -18397,18 +19426,22 @@ class WalkerUtils {
          * Stop signal is filtered by walkerName to prevent interference.
          *
          * @param symbol - Trading pair symbol
-         * @param walkerName - Walker name to stop
+         * @param context - Execution context with walker name
          * @returns Promise that resolves when all stop flags are set
          *
          * @example
          * ```typescript
          * // Stop walker and all its strategies
-         * await Walker.stop("BTCUSDT", "my-walker");
+         * await Walker.stop("BTCUSDT", { walkerName: "my-walker" });
          * ```
          */
-        this.stop = async (symbol, walkerName) => {
-            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_STOP);
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+        this.stop = async (symbol, context) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_STOP, {
+                symbol,
+                context,
+            });
+            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_STOP);
+            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_STOP);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -18418,7 +19451,7 @@ class WalkerUtils {
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP));
             }
             for (const strategyName of walkerSchema.strategies) {
-                await walkerStopSubject.next({ symbol, strategyName, walkerName });
+                await walkerStopSubject.next({ symbol, strategyName, walkerName: context.walkerName });
                 await backtest$1.strategyCoreService.stop(true, symbol, {
                     strategyName,
                     exchangeName: walkerSchema.exchangeName,
@@ -18430,18 +19463,22 @@ class WalkerUtils {
          * Gets walker results data from all strategy comparisons.
          *
          * @param symbol - Trading symbol
-         * @param walkerName - Walker name to get data for
+         * @param context - Execution context with walker name
          * @returns Promise resolving to walker results data object
          *
          * @example
          * ```typescript
-         * const results = await Walker.getData("BTCUSDT", "my-walker");
+         * const results = await Walker.getData("BTCUSDT", { walkerName: "my-walker" });
          * console.log(results.bestStrategy, results.bestMetric);
          * ```
          */
-        this.getData = async (symbol, walkerName) => {
-            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_GET_DATA);
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+        this.getData = async (symbol, context) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_DATA, {
+                symbol,
+                context,
+            });
+            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_GET_DATA);
+            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_DATA);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -18450,7 +19487,7 @@ class WalkerUtils {
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA));
             }
-            return await backtest$1.walkerMarkdownService.getData(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+            return await backtest$1.walkerMarkdownService.getData(context.walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
             });
@@ -18459,20 +19496,24 @@ class WalkerUtils {
          * Generates markdown report with all strategy comparisons for a walker.
          *
          * @param symbol - Trading symbol
-         * @param walkerName - Walker name to generate report for
+         * @param context - Execution context with walker name
          * @param strategyColumns - Optional strategy columns configuration
          * @param pnlColumns - Optional PNL columns configuration
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
          * ```typescript
-         * const markdown = await Walker.getReport("BTCUSDT", "my-walker");
+         * const markdown = await Walker.getReport("BTCUSDT", { walkerName: "my-walker" });
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, walkerName, strategyColumns, pnlColumns) => {
-            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_GET_REPORT);
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+        this.getReport = async (symbol, context, strategyColumns, pnlColumns) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_REPORT, {
+                symbol,
+                context,
+            });
+            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_GET_REPORT);
+            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_REPORT);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -18481,7 +19522,7 @@ class WalkerUtils {
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.walkerMarkdownService.getReport(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+            return await backtest$1.walkerMarkdownService.getReport(context.walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
             }, strategyColumns, pnlColumns);
@@ -18490,7 +19531,7 @@ class WalkerUtils {
          * Saves walker report to disk.
          *
          * @param symbol - Trading symbol
-         * @param walkerName - Walker name to save report for
+         * @param context - Execution context with walker name
          * @param path - Optional directory path to save report (default: "./dump/walker")
          * @param strategyColumns - Optional strategy columns configuration
          * @param pnlColumns - Optional PNL columns configuration
@@ -18498,15 +19539,20 @@ class WalkerUtils {
          * @example
          * ```typescript
          * // Save to default path: ./dump/walker/my-walker.md
-         * await Walker.dump("BTCUSDT", "my-walker");
+         * await Walker.dump("BTCUSDT", { walkerName: "my-walker" });
          *
          * // Save to custom path: ./custom/path/my-walker.md
-         * await Walker.dump("BTCUSDT", "my-walker", "./custom/path");
+         * await Walker.dump("BTCUSDT", { walkerName: "my-walker" }, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, walkerName, path, strategyColumns, pnlColumns) => {
-            backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_DUMP);
-            const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
+        this.dump = async (symbol, context, path, strategyColumns, pnlColumns) => {
+            backtest$1.loggerService.info(WALKER_METHOD_NAME_DUMP, {
+                symbol,
+                context,
+                path,
+            });
+            backtest$1.walkerValidationService.validate(context.walkerName, WALKER_METHOD_NAME_DUMP);
+            const walkerSchema = backtest$1.walkerSchemaService.get(context.walkerName);
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_DUMP);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -18515,7 +19561,7 @@ class WalkerUtils {
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP));
             }
-            await backtest$1.walkerMarkdownService.dump(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
+            await backtest$1.walkerMarkdownService.dump(context.walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
             }, path, strategyColumns, pnlColumns);
@@ -20335,6 +21381,8 @@ exports.listenWalker = listenWalker;
 exports.listenWalkerComplete = listenWalkerComplete;
 exports.listenWalkerOnce = listenWalkerOnce;
 exports.listenWalkerProgress = listenWalkerProgress;
+exports.partialLoss = partialLoss;
+exports.partialProfit = partialProfit;
 exports.setColumns = setColumns;
 exports.setConfig = setConfig;
 exports.setLogger = setLogger;