backtest-kit 5.5.3 → 5.6.1

package/build/index.mjs

@@ -107,6 +107,7 @@ const markdownServices$1 = {
     riskMarkdownService: Symbol('riskMarkdownService'),
     strategyMarkdownService: Symbol('strategyMarkdownService'),
     syncMarkdownService: Symbol('syncMarkdownService'),
+    highestProfitMarkdownService: Symbol('highestProfitMarkdownService'),
 };
 const reportServices$1 = {
     backtestReportService: Symbol('backtestReportService'),
@@ -120,6 +121,7 @@ const reportServices$1 = {
     riskReportService: Symbol('riskReportService'),
     strategyReportService: Symbol('strategyReportService'),
     syncReportService: Symbol('syncReportService'),
+    highestProfitReportService: Symbol('highestProfitReportService'),
 };
 const validationServices$1 = {
     exchangeValidationService: Symbol('exchangeValidationService'),
@@ -622,6 +624,12 @@ const strategyCommitSubject = new Subject();
  * BacktestLogicPrivateService::*run
  */
 const backtestScheduleOpenSubject = new Subject();
+/**
+ * Highest profit emitter for real-time profit tracking.
+ * Emits updates on the highest profit achieved for an open position.
+ * Allows users to track profit milestones and implement custom management logic based on profit levels.
+ */
+const highestProfitSubject = new Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -633,6 +641,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     doneWalkerSubject: doneWalkerSubject,
     errorEmitter: errorEmitter,
     exitEmitter: exitEmitter,
+    highestProfitSubject: highestProfitSubject,
     partialLossSubject: partialLossSubject,
     partialProfitSubject: partialProfitSubject,
     performanceEmitter: performanceEmitter,
@@ -4251,6 +4260,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
                 timestamp: currentTime,
                 _isScheduled: false,
                 _entry: [{ price: signal.priceOpen, cost: signal.cost ?? GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, timestamp: currentTime }],
+                _peak: { price: signal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
             };
             // Валидируем сигнал перед возвратом
             VALIDATE_SIGNAL_FN(signalRow, currentPrice, false);
@@ -4275,6 +4285,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
             timestamp: currentTime,
             _isScheduled: true,
             _entry: [{ price: signal.priceOpen, cost: signal.cost ?? GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, timestamp: currentTime }],
+            _peak: { price: signal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
         };
         // Валидируем сигнал перед возвратом
         VALIDATE_SIGNAL_FN(scheduledSignalRow, currentPrice, true);
@@ -4295,6 +4306,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         timestamp: currentTime,
         _isScheduled: false,
         _entry: [{ price: currentPrice, cost: signal.cost ?? GLOBAL_CONFIG.CC_POSITION_ENTRY_COST, timestamp: currentTime }],
+        _peak: { price: currentPrice, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
     };
     // Валидируем сигнал перед возвратом
     VALIDATE_SIGNAL_FN(signalRow, currentPrice, false);
@@ -4997,6 +5009,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
         ...scheduled,
         pendingAt: activationTime,
         _isScheduled: false,
+        _peak: { price: scheduled.priceOpen, timestamp: activationTime, pnlPercentage: 0, pnlCost: 0 },
     };
     // Sync open: if external system rejects — cancel scheduled signal instead of opening
     const syncOpenAllowed = await CALL_SIGNAL_SYNC_OPEN_FN(activationTime, activatedSignal.priceOpen, activatedSignal, self);
@@ -5633,7 +5646,7 @@ const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason)
     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) => {
+const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice, backtest) => {
     let percentTp = 0;
     let percentSl = 0;
     const currentTime = self.params.execution.context.when.getTime();
@@ -5654,6 +5667,15 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
                 const tpDistance = effectiveTakeProfit - effectivePriceOpen;
                 const progressPercent = (currentDistance / tpDistance) * 100;
                 percentTp = Math.min(progressPercent, 100);
+                if (currentPrice > signal._peak.price) {
+                    const { pnl } = TO_PUBLIC_SIGNAL(signal, currentPrice);
+                    signal._peak = { price: currentPrice, timestamp: currentTime, pnlCost: pnl.pnlCost, pnlPercentage: pnl.pnlPercentage };
+                    if (self.params.callbacks?.onWrite) {
+                        self.params.callbacks.onWrite(signal.symbol, signal, backtest);
+                    }
+                    !backtest && await PersistSignalAdapter.writeSignalData(signal, self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName);
+                    await self.params.onHighestProfit(TO_PUBLIC_SIGNAL(signal, currentPrice), currentPrice, currentTime);
+                }
                 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) {
@@ -5678,6 +5700,15 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
                 const tpDistance = effectivePriceOpen - effectiveTakeProfit;
                 const progressPercent = (currentDistance / tpDistance) * 100;
                 percentTp = Math.min(progressPercent, 100);
+                if (currentPrice < signal._peak.price) {
+                    const { pnl } = TO_PUBLIC_SIGNAL(signal, currentPrice);
+                    signal._peak = { price: currentPrice, timestamp: currentTime, pnlCost: pnl.pnlCost, pnlPercentage: pnl.pnlPercentage };
+                    if (self.params.callbacks?.onWrite) {
+                        self.params.callbacks.onWrite(signal.symbol, signal, backtest);
+                    }
+                    !backtest && await PersistSignalAdapter.writeSignalData(signal, self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName);
+                    await self.params.onHighestProfit(TO_PUBLIC_SIGNAL(signal, currentPrice), currentPrice, currentTime);
+                }
                 await CALL_PARTIAL_PROFIT_CALLBACKS_FN(self, self.params.execution.context.symbol, signal, currentPrice, percentTp, currentTime, self.params.execution.context.backtest);
             }
             if (currentDistance < 0) {
@@ -5725,7 +5756,7 @@ const RETURN_IDLE_FN = async (self, currentPrice) => {
     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) => {
+const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePrice, closeTimestamp, reason, cancelId) => {
     self.params.logger.info("ClientStrategy backtest scheduled signal cancelled", {
         symbol: self.params.execution.context.symbol,
         signalId: scheduled.id,
@@ -5735,6 +5766,23 @@ const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePr
         reason,
     });
     await self.setScheduledSignal(null);
+    if (reason === "user") {
+        await CALL_COMMIT_FN(self, {
+            action: "cancel-scheduled",
+            symbol: self.params.execution.context.symbol,
+            strategyName: self.params.strategyName,
+            exchangeName: self.params.exchangeName,
+            frameName: self.params.frameName,
+            signalId: scheduled.id,
+            backtest: true,
+            cancelId,
+            timestamp: closeTimestamp,
+            totalEntries: scheduled._entry?.length ?? 1,
+            totalPartials: scheduled._partial?.length ?? 0,
+            originalPriceOpen: scheduled.priceOpen,
+            pnl: toProfitLossDto(scheduled, averagePrice),
+        });
+    }
     await CALL_CANCEL_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, averagePrice, closeTimestamp, self.params.execution.context.backtest);
     const result = {
         action: "cancelled",
@@ -5747,6 +5795,7 @@ const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePr
         symbol: self.params.execution.context.symbol,
         backtest: self.params.execution.context.backtest,
         reason,
+        cancelId,
         createdAt: closeTimestamp,
     };
     await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
@@ -5786,6 +5835,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
         ...scheduled,
         pendingAt: activationTime,
         _isScheduled: false,
+        _peak: { price: scheduled.priceOpen, timestamp: activationTime, pnlPercentage: 0, pnlCost: 0 },
     };
     // Sync open: if external system rejects — cancel scheduled signal instead of opening
     const syncOpenAllowed = await CALL_SIGNAL_SYNC_OPEN_FN(activationTime, activatedSignal.priceOpen, activatedSignal, self);
@@ -5935,7 +5985,8 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
         // КРИТИЧНО: Проверяем был ли сигнал отменен пользователем через cancel()
         if (self._cancelledSignal) {
             // Сигнал был отменен через cancel() в onSchedulePing
-            const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "user");
+            const cancelId = self._cancelledSignal.cancelId;
+            const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "user", cancelId);
             return { outcome: "cancelled", result };
         }
         // КРИТИЧНО: Проверяем был ли сигнал активирован пользователем через activateScheduled()
@@ -5965,6 +6016,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
                 ...activatedSignal,
                 pendingAt: candle.timestamp,
                 _isScheduled: false,
+                _peak: { price: activatedSignal.priceOpen, timestamp: candle.timestamp, pnlPercentage: 0, pnlCost: 0 },
             };
             // Sync open: if external system rejects — cancel scheduled signal instead of opening
             const syncOpenAllowed = await CALL_SIGNAL_SYNC_OPEN_FN(candle.timestamp, pendingSignal.priceOpen, pendingSignal, self);
@@ -6166,6 +6218,14 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
                     const tpDistance = effectiveTakeProfit - effectivePriceOpen;
                     const progressPercent = (currentDistance / tpDistance) * 100;
+                    if (averagePrice > signal._peak.price) {
+                        const { pnl } = TO_PUBLIC_SIGNAL(signal, averagePrice);
+                        signal._peak = { price: averagePrice, timestamp: currentCandleTimestamp, pnlCost: pnl.pnlCost, pnlPercentage: pnl.pnlPercentage };
+                        if (self.params.callbacks?.onWrite) {
+                            self.params.callbacks.onWrite(signal.symbol, signal, true);
+                        }
+                        await self.params.onHighestProfit(TO_PUBLIC_SIGNAL(signal, averagePrice), averagePrice, currentCandleTimestamp);
+                    }
                     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) {
@@ -6188,6 +6248,14 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     const effectiveTakeProfit = signal._trailingPriceTakeProfit ?? signal.priceTakeProfit;
                     const tpDistance = effectivePriceOpen - effectiveTakeProfit;
                     const progressPercent = (currentDistance / tpDistance) * 100;
+                    if (averagePrice < signal._peak.price) {
+                        const { pnl } = TO_PUBLIC_SIGNAL(signal, averagePrice);
+                        signal._peak = { price: averagePrice, timestamp: currentCandleTimestamp, pnlCost: pnl.pnlCost, pnlPercentage: pnl.pnlPercentage };
+                        if (self.params.callbacks?.onWrite) {
+                            self.params.callbacks.onWrite(signal.symbol, signal, true);
+                        }
+                        await self.params.onHighestProfit(TO_PUBLIC_SIGNAL(signal, averagePrice), averagePrice, currentCandleTimestamp);
+                    }
                     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) {
@@ -6564,8 +6632,8 @@ class ClientStrategy {
      * @param symbol - Trading pair symbol
      * @returns Promise resolving to effective entry price or null
      */
-    async getPositionAveragePrice(symbol) {
-        this.params.logger.debug("ClientStrategy getPositionAveragePrice", { symbol });
+    async getPositionEffectivePrice(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionEffectivePrice", { symbol });
         if (!this._pendingSignal) {
             return null;
         }
@@ -6722,6 +6790,170 @@ class ClientStrategy {
         }
         return entries.map(({ price, cost, timestamp }) => ({ price, cost, timestamp }));
     }
+    /**
+     * Returns the original estimated duration for the current pending signal.
+     *
+     * Reflects `minuteEstimatedTime` as set in the signal DTO — the maximum
+     * number of minutes the position is expected to be active before `time_expired`.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to estimated duration in minutes or null
+     */
+    async getPositionEstimateMinutes(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionEstimateMinutes", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return this._pendingSignal.minuteEstimatedTime;
+    }
+    /**
+     * Returns the remaining time before the position expires, clamped to zero.
+     *
+     * Computes elapsed minutes since `pendingAt` and subtracts from `minuteEstimatedTime`.
+     * Returns 0 once the estimate is exceeded (never negative).
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param timestamp - Current Unix timestamp in milliseconds
+     * @returns Promise resolving to remaining minutes (≥ 0) or null
+     */
+    async getPositionCountdownMinutes(symbol, timestamp) {
+        this.params.logger.debug("ClientStrategy getPositionCountdownMinutes", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const elapsed = Math.floor((timestamp - this._pendingSignal.pendingAt) / 60000);
+        return Math.max(0, this._pendingSignal.minuteEstimatedTime - elapsed);
+    }
+    /**
+     * Returns the best price reached in the profit direction during this position's life.
+     *
+     * Initialized at position open with the entry price and timestamp.
+     * Updated on every tick/candle when VWAP moves beyond the previous record toward TP:
+     * - LONG: tracks the highest price seen above effective entry
+     * - SHORT: tracks the lowest price seen below effective entry
+     *
+     * Returns null if no pending signal exists.
+     * Never returns null when a signal is active — always contains at least the entry price.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to price or null
+     */
+    async getPositionHighestProfitPrice(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionHighestProfitPrice", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return this._pendingSignal._peak.price;
+    }
+    /**
+     * Returns the timestamp when the best profit price was recorded during this position's life.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to timestamp in milliseconds or null
+     */
+    async getPositionHighestProfitTimestamp(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionHighestProfitTimestamp", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return this._pendingSignal._peak.timestamp;
+    }
+    /**
+     * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+     *
+     * Initialized at position open with 0.
+     * Updated on every tick/candle when VWAP moves beyond the previous record toward TP:
+     * - LONG: tracks the PnL percentage at the highest price seen above effective entry
+     * - SHORT: tracks the PnL percentage at the lowest price seen below effective entry
+     *
+     * Returns null if no pending signal exists.
+     * Never returns null when a signal is active — always contains at least 0.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to PnL percentage or null
+     */
+    async getPositionHighestPnlPercentage(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionHighestPnlPercentage", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return this._pendingSignal._peak.pnlPercentage;
+    }
+    /**
+     * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+     *
+     * Initialized at position open with 0.
+     * Updated on every tick/candle when VWAP moves beyond the previous record toward TP:
+     * - LONG: tracks the PnL cost at the highest price seen above effective entry
+     * - SHORT: tracks the PnL cost at the lowest price seen below effective entry
+     *
+     * Returns null if no pending signal exists.
+     * Never returns null when a signal is active — always contains at least 0.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to PnL cost or null
+     */
+    async getPositionHighestPnlCost(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionHighestPnlCost", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return this._pendingSignal._peak.pnlCost;
+    }
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Measures how long the position has been pulling back from its peak profit level.
+     * Zero when called at the exact moment the peak was set.
+     * Grows continuously as price moves away from the peak without setting a new record.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param timestamp - Current Unix timestamp in milliseconds
+     * @returns Promise resolving to drawdown duration in minutes or null
+     */
+    async getPositionHighestProfitBreakeven(symbol) {
+        this.params.logger.debug("ClientStrategy getPositionHighestProfitBreakeven", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const signal = this._pendingSignal;
+        const effectivePriceOpen = getEffectivePriceOpen(signal);
+        const peakPrice = signal._peak.price;
+        const breakevenThresholdPercent = (GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE + GLOBAL_CONFIG.CC_PERCENT_FEE) * 2 + GLOBAL_CONFIG.CC_BREAKEVEN_THRESHOLD;
+        if (signal.position === "long") {
+            return peakPrice >= effectivePriceOpen * (1 + breakevenThresholdPercent / 100);
+        }
+        else {
+            return peakPrice <= effectivePriceOpen * (1 - breakevenThresholdPercent / 100);
+        }
+    }
+    /**
+     * Returns the number of minutes elapsed since the highest profit price was recorded.
+     *
+     * Measures how long the position has been pulling back from its peak.
+     * Zero when called at the exact moment the peak was set.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param timestamp - Current Unix timestamp in milliseconds
+     * @returns Promise resolving to drawdown duration in minutes or null
+     */
+    async getPositionDrawdownMinutes(symbol, timestamp) {
+        this.params.logger.debug("ClientStrategy getPositionDrawdownMinutes", { symbol });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return Math.floor((timestamp - this._pendingSignal._peak.timestamp) / 60000);
+    }
     /**
      * Performs a single tick of strategy execution.
      *
@@ -6897,6 +7129,7 @@ class ClientStrategy {
                 ...activatedSignal,
                 pendingAt: currentTime,
                 _isScheduled: false,
+                _peak: { price: activatedSignal.priceOpen, timestamp: currentTime, pnlPercentage: 0, pnlCost: 0 },
             };
             const syncOpenAllowed = await CALL_SIGNAL_SYNC_OPEN_FN(currentTime, currentPrice, pendingSignal, this);
             if (!syncOpenAllowed) {
@@ -7019,7 +7252,7 @@ class ClientStrategy {
         if (closedResult) {
             return closedResult;
         }
-        return await RETURN_PENDING_SIGNAL_ACTIVE_FN(this, this._pendingSignal, averagePrice);
+        return await RETURN_PENDING_SIGNAL_ACTIVE_FN(this, this._pendingSignal, averagePrice, false);
     }
     /**
      * Fast backtests a signal using historical candle data.
@@ -9006,7 +9239,7 @@ const GET_RISK_FN = (dto, backtest, exchangeName, frameName, self) => {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$o = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$p = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -9130,6 +9363,43 @@ const CREATE_COMMIT_FN = (self) => trycatch(async (event) => {
     },
     defaultValue: null,
 });
+/**
+ * Creates a callback function for emitting highest profit updates to highestProfitSubject.
+ * Called by ClientStrategy when the highest profit for an open position is updated.
+ * Emits HighestProfitContract event to all subscribers with the current price and timestamp.
+ * Used for real-time profit tracking and management logic based on profit levels.
+ *
+ * @param self - Reference to StrategyConnectionService instance
+ * @param strategyName - Name of the strategy
+ * @param exchangeName - Name of the exchange
+ * @param frameName - Name of the frame
+ * @param isBacktest - Flag indicating if the operation is for backtesting
+ * @returns Callback function for highest profit updates
+ */
+const CREATE_HIGHEST_PROFIT_FN = (self, strategyName, exchangeName, frameName, isBacktest) => trycatch(async (signal, currentPrice, timestamp) => {
+    await highestProfitSubject.next({
+        symbol: signal.symbol,
+        signal,
+        currentPrice,
+        timestamp,
+        strategyName,
+        exchangeName,
+        frameName,
+        backtest: isBacktest,
+    });
+}, {
+    fallback: (error) => {
+        const message = "StrategyConnectionService CREATE_HIGHEST_PROFIT_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
  * Creates a callback function for emitting dispose events.
  *
@@ -9200,7 +9470,7 @@ class StrategyConnectionService {
          * @param backtest - Whether running in backtest mode
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$o(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
+        this.getStrategy = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$p(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
             const { riskName = "", riskList = [], getSignal, interval, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
@@ -9228,6 +9498,7 @@ class StrategyConnectionService {
                 onDispose: CREATE_COMMIT_DISPOSE_FN(this),
                 onCommit: CREATE_COMMIT_FN(),
                 onSignalSync: CREATE_SYNC_FN(this, strategyName, exchangeName, frameName, backtest),
+                onHighestProfit: CREATE_HIGHEST_PROFIT_FN(this, strategyName, exchangeName, frameName, backtest),
             });
         });
         /**
@@ -9301,14 +9572,14 @@ class StrategyConnectionService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise resolving to effective entry price or null
          */
-        this.getPositionAveragePrice = async (backtest, symbol, context) => {
-            this.loggerService.log("strategyConnectionService getPositionAveragePrice", {
+        this.getPositionEffectivePrice = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionEffectivePrice", {
                 symbol,
                 context,
                 backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            return await strategy.getPositionAveragePrice(symbol);
+            return await strategy.getPositionEffectivePrice(symbol);
         };
         /**
          * Returns the number of DCA entries made for the current pending signal.
@@ -9658,6 +9929,162 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.hasPendingSignal(symbol);
         };
+        /**
+         * Returns the original estimated duration for the current pending signal.
+         *
+         * Delegates to ClientStrategy.getPositionEstimateMinutes().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to estimated duration in minutes or null
+         */
+        this.getPositionEstimateMinutes = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionEstimateMinutes", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionEstimateMinutes(symbol);
+        };
+        /**
+         * Returns the remaining time before the position expires, clamped to zero.
+         *
+         * Resolves current timestamp via timeMetaService and delegates to
+         * ClientStrategy.getPositionCountdownMinutes().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to remaining minutes (≥ 0) or null
+         */
+        this.getPositionCountdownMinutes = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionCountdownMinutes", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const timestamp = await this.timeMetaService.getTimestamp(symbol, context, backtest);
+            return await strategy.getPositionCountdownMinutes(symbol, timestamp);
+        };
+        /**
+         * Returns the best price reached in the profit direction during this position's life.
+         *
+         * Delegates to ClientStrategy.getPositionHighestProfitPrice().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to price or null
+         */
+        this.getPositionHighestProfitPrice = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionHighestProfitPrice", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionHighestProfitPrice(symbol);
+        };
+        /**
+         * Returns the timestamp when the best profit price was recorded during this position's life.
+         *
+         * Delegates to ClientStrategy.getPositionHighestProfitTimestamp().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to timestamp in milliseconds or null
+         */
+        this.getPositionHighestProfitTimestamp = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionHighestProfitTimestamp", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionHighestProfitTimestamp(symbol);
+        };
+        /**
+         * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+         *
+         * Delegates to ClientStrategy.getPositionHighestPnlPercentage().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to PnL percentage or null
+         */
+        this.getPositionHighestPnlPercentage = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionHighestPnlPercentage", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionHighestPnlPercentage(symbol);
+        };
+        /**
+         * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+         *
+         * Delegates to ClientStrategy.getPositionHighestPnlCost().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to PnL cost or null
+         */
+        this.getPositionHighestPnlCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionHighestPnlCost", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionHighestPnlCost(symbol);
+        };
+        /**
+         * Returns whether breakeven was mathematically reachable at the highest profit price.
+         *
+         * Delegates to ClientStrategy.getPositionHighestProfitBreakeven().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to true if breakeven was reachable at peak, false otherwise, or null
+         */
+        this.getPositionHighestProfitBreakeven = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionHighestProfitBreakeven", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPositionHighestProfitBreakeven(symbol);
+        };
+        /**
+         * Returns the number of minutes elapsed since the highest profit price was recorded.
+         *
+         * Resolves current timestamp via timeMetaService and delegates to
+         * ClientStrategy.getPositionDrawdownMinutes().
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to drawdown duration in minutes or null
+         */
+        this.getPositionDrawdownMinutes = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionDrawdownMinutes", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const timestamp = await this.timeMetaService.getTimestamp(symbol, context, backtest);
+            return await strategy.getPositionDrawdownMinutes(symbol, timestamp);
+        };
         /**
          * Disposes the ClientStrategy instance for the given context.
          *
@@ -9696,7 +10123,7 @@ class StrategyConnectionService {
                 }
                 return;
             }
-            const key = CREATE_KEY_FN$o(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$p(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             if (!this.getStrategy.has(key)) {
                 return;
             }
@@ -10869,7 +11296,7 @@ class ClientRisk {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$n = (riskName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$o = (riskName, exchangeName, frameName, backtest) => {
     const parts = [riskName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -10968,7 +11395,7 @@ class RiskConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientRisk instance
          */
-        this.getRisk = memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$n(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
+        this.getRisk = memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$o(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
             const schema = this.riskSchemaService.get(riskName);
             return new ClientRisk({
                 ...schema,
@@ -11036,7 +11463,7 @@ class RiskConnectionService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$n(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$o(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getRisk.clear(key);
             }
             else {
@@ -12503,7 +12930,7 @@ class ClientAction {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$m = (actionName, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$n = (actionName, strategyName, exchangeName, frameName, backtest) => {
     const parts = [actionName, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -12554,7 +12981,7 @@ class ActionConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientAction instance
          */
-        this.getAction = memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$m(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
+        this.getAction = memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$n(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
             const schema = this.actionSchemaService.get(actionName);
             return new ClientAction({
                 ...schema,
@@ -12764,7 +13191,7 @@ class ActionConnectionService {
                 await Promise.all(actions.map(async (action) => await action.dispose()));
                 return;
             }
-            const key = CREATE_KEY_FN$m(payload.actionName, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$n(payload.actionName, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             if (!this.getAction.has(key)) {
                 return;
             }
@@ -12782,7 +13209,7 @@ const METHOD_NAME_VALIDATE$2 = "exchangeCoreService validate";
  * @param exchangeName - Exchange name
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$l = (exchangeName) => {
+const CREATE_KEY_FN$m = (exchangeName) => {
     return exchangeName;
 };
 /**
@@ -12806,7 +13233,7 @@ class ExchangeCoreService {
          * @param exchangeName - Name of the exchange to validate
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([exchangeName]) => CREATE_KEY_FN$l(exchangeName), async (exchangeName) => {
+        this.validate = memoize(([exchangeName]) => CREATE_KEY_FN$m(exchangeName), async (exchangeName) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$2, {
                 exchangeName,
             });
@@ -13058,7 +13485,7 @@ const METHOD_NAME_VALIDATE$1 = "strategyCoreService validate";
  * @param context - Execution context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$k = (context) => {
+const CREATE_KEY_FN$l = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -13090,7 +13517,7 @@ class StrategyCoreService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$k(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$l(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$1, {
                 context,
             });
@@ -13154,13 +13581,13 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.getTotalCostClosed(backtest, symbol, context);
         };
-        this.getPositionAveragePrice = async (backtest, symbol, context) => {
-            this.loggerService.log("strategyCoreService getPositionAveragePrice", {
+        this.getPositionEffectivePrice = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionEffectivePrice", {
                 symbol,
                 context,
             });
             await this.validate(context);
-            return await this.strategyConnectionService.getPositionAveragePrice(backtest, symbol, context);
+            return await this.strategyConnectionService.getPositionEffectivePrice(backtest, symbol, context);
         };
         this.getPositionInvestedCount = async (backtest, symbol, context) => {
             this.loggerService.log("strategyCoreService getPositionInvestedCount", {
@@ -13853,6 +14280,143 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.hasPendingSignal(backtest, symbol, context);
         };
+        /**
+         * Returns the original estimated duration for the current pending signal.
+         *
+         * Validates strategy existence and delegates to connection service.
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to estimated duration in minutes or null
+         */
+        this.getPositionEstimateMinutes = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionEstimateMinutes", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionEstimateMinutes(backtest, symbol, context);
+        };
+        /**
+         * Returns the remaining time before the position expires, clamped to zero.
+         *
+         * Validates strategy existence and delegates to connection service.
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to remaining minutes (≥ 0) or null
+         */
+        this.getPositionCountdownMinutes = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionCountdownMinutes", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionCountdownMinutes(backtest, symbol, context);
+        };
+        /**
+         * Returns the best price reached in the profit direction during this position's life.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to price or null
+         */
+        this.getPositionHighestProfitPrice = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionHighestProfitPrice", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionHighestProfitPrice(backtest, symbol, context);
+        };
+        /**
+         * Returns the timestamp when the best profit price was recorded during this position's life.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to timestamp in milliseconds or null
+         */
+        this.getPositionHighestProfitTimestamp = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionHighestProfitTimestamp", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionHighestProfitTimestamp(backtest, symbol, context);
+        };
+        /**
+         * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to PnL percentage or null
+         */
+        this.getPositionHighestPnlPercentage = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionHighestPnlPercentage", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionHighestPnlPercentage(backtest, symbol, context);
+        };
+        /**
+         * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to PnL cost or null
+         */
+        this.getPositionHighestPnlCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionHighestPnlCost", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionHighestPnlCost(backtest, symbol, context);
+        };
+        /**
+         * Returns whether breakeven was mathematically reachable at the highest profit price.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to true if breakeven was reachable at peak, false otherwise, or null
+         */
+        this.getPositionHighestProfitBreakeven = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionHighestProfitBreakeven", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionHighestProfitBreakeven(backtest, symbol, context);
+        };
+        /**
+         * Returns the number of minutes elapsed since the highest profit price was recorded.
+         *
+         * Validates strategy existence and delegates to connection service.
+         * Returns null if no pending signal exists.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @returns Promise resolving to drawdown duration in minutes or null
+         */
+        this.getPositionDrawdownMinutes = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionDrawdownMinutes", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionDrawdownMinutes(backtest, symbol, context);
+        };
     }
 }
 
@@ -13925,7 +14489,7 @@ class SizingGlobalService {
  * @param context - Context with riskName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$j = (context) => {
+const CREATE_KEY_FN$k = (context) => {
     const parts = [context.riskName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -13951,7 +14515,7 @@ class RiskGlobalService {
          * @param payload - Payload with riskName, exchangeName and frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$j(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$k(context), async (context) => {
             this.loggerService.log("riskGlobalService validate", {
                 context,
             });
@@ -14029,7 +14593,7 @@ const METHOD_NAME_VALIDATE = "actionCoreService validate";
  * @param context - Execution context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$i = (context) => {
+const CREATE_KEY_FN$j = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -14073,7 +14637,7 @@ class ActionCoreService {
          * @param context - Strategy execution context with strategyName, exchangeName and frameName
          * @returns Promise that resolves when all validations complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$i(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$j(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE, {
                 context,
             });
@@ -17884,6 +18448,93 @@ const sync_columns = [
     },
 ];
 
+/**
+ * Column configuration for highest profit markdown reports.
+ *
+ * Defines the table structure for displaying highest-profit-record events.
+ *
+ * @see HighestProfitMarkdownService
+ * @see ColumnModel
+ * @see HighestProfitEvent
+ */
+const highest_profit_columns = [
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "strategyName",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+        isVisible: () => true,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.signalId,
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.position.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "pnl",
+        label: "PNL (net)",
+        format: (data) => {
+            const pnlPercentage = data.pnl.pnlPercentage;
+            return `${pnlPercentage > 0 ? "+" : ""}${pnlPercentage.toFixed(2)}%`;
+        },
+        isVisible: () => true,
+    },
+    {
+        key: "pnlCost",
+        label: "PNL (USD)",
+        format: (data) => `${data.pnl.pnlCost > 0 ? "+" : ""}${data.pnl.pnlCost.toFixed(2)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "currentPrice",
+        label: "Record Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "priceOpen",
+        label: "Entry Price",
+        format: (data) => `${data.priceOpen.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "priceTakeProfit",
+        label: "Take Profit",
+        format: (data) => `${data.priceTakeProfit.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "priceStopLoss",
+        label: "Stop Loss",
+        format: (data) => `${data.priceStopLoss.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+        isVisible: () => true,
+    },
+    {
+        key: "mode",
+        label: "Mode",
+        format: (data) => (data.backtest ? "Backtest" : "Live"),
+        isVisible: () => true,
+    },
+];
+
 /**
  * Column configuration for walker strategy comparison table in markdown reports.
  *
@@ -18101,6 +18752,8 @@ const COLUMN_CONFIG = {
     strategy_columns,
     /** Columns for signal sync lifecycle events (signal-open, signal-close) */
     sync_columns,
+    /** Columns for highest profit milestone tracking events */
+    highest_profit_columns,
     /** Walker: PnL summary columns */
     walker_pnl_columns,
     /** Walker: strategy-level summary columns */
@@ -18141,6 +18794,7 @@ const WILDCARD_TARGET$1 = {
     schedule: true,
     walker: true,
     sync: true,
+    highest_profit: true,
 };
 /**
  * JSONL-based markdown adapter with append-only writes.
@@ -18368,7 +19022,7 @@ class MarkdownUtils {
          *
          * @returns Cleanup function that unsubscribes from all enabled services
          */
-        this.enable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, strategy = false, risk = false, schedule = false, walker = false, sync = false, } = WILDCARD_TARGET$1) => {
+        this.enable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, strategy = false, risk = false, schedule = false, walker = false, sync = false, highest_profit = false, } = WILDCARD_TARGET$1) => {
             bt.loggerService.debug(MARKDOWN_METHOD_NAME_ENABLE, {
                 backtest: bt$1,
                 breakeven,
@@ -18381,6 +19035,7 @@ class MarkdownUtils {
                 schedule,
                 walker,
                 sync,
+                highest_profit,
             });
             const unList = [];
             if (bt$1) {
@@ -18416,6 +19071,9 @@ class MarkdownUtils {
             if (sync) {
                 unList.push(bt.syncMarkdownService.subscribe());
             }
+            if (highest_profit) {
+                unList.push(bt.highestProfitMarkdownService.subscribe());
+            }
             return compose(...unList.map((un) => () => void un()));
         };
         /**
@@ -18455,7 +19113,7 @@ class MarkdownUtils {
          * Markdown.disable();
          * ```
          */
-        this.disable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, strategy = false, schedule = false, walker = false, sync = false, } = WILDCARD_TARGET$1) => {
+        this.disable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, strategy = false, schedule = false, walker = false, sync = false, highest_profit = false, } = WILDCARD_TARGET$1) => {
             bt.loggerService.debug(MARKDOWN_METHOD_NAME_DISABLE, {
                 backtest: bt$1,
                 breakeven,
@@ -18468,6 +19126,7 @@ class MarkdownUtils {
                 schedule,
                 walker,
                 sync,
+                highest_profit,
             });
             if (bt$1) {
                 bt.backtestMarkdownService.unsubscribe();
@@ -18502,6 +19161,9 @@ class MarkdownUtils {
             if (sync) {
                 bt.syncMarkdownService.unsubscribe();
             }
+            if (highest_profit) {
+                bt.highestProfitMarkdownService.unsubscribe();
+            }
         };
     }
 }
@@ -18608,7 +19270,7 @@ const Markdown = new MarkdownAdapter();
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$h = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$i = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -18625,7 +19287,7 @@ const CREATE_KEY_FN$h = (symbol, strategyName, exchangeName, frameName, backtest
  * @param timestamp - Unix timestamp in milliseconds
  * @returns Filename string
  */
-const CREATE_FILE_NAME_FN$a = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$b = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -18654,12 +19316,12 @@ function isUnsafe$3(value) {
     return false;
 }
 /** Maximum number of signals to store in backtest reports */
-const MAX_EVENTS$9 = 250;
+const MAX_EVENTS$a = 250;
 /**
  * Storage class for accumulating closed signals per strategy.
  * Maintains a list of all closed signals and provides methods to generate reports.
  */
-let ReportStorage$8 = class ReportStorage {
+let ReportStorage$9 = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -18676,7 +19338,7 @@ let ReportStorage$8 = class ReportStorage {
     addSignal(data) {
         this._signalList.unshift(data);
         // Trim queue if exceeded MAX_EVENTS
-        if (this._signalList.length > MAX_EVENTS$9) {
+        if (this._signalList.length > MAX_EVENTS$a) {
             this._signalList.pop();
         }
     }
@@ -18800,7 +19462,7 @@ let ReportStorage$8 = class ReportStorage {
     async dump(strategyName, path = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) {
         const markdown = await this.getReport(strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$a(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$b(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("backtest", markdown, {
             path,
             file: filename,
@@ -18847,7 +19509,7 @@ class BacktestMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$h(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$8(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$i(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$9(symbol, strategyName, exchangeName, frameName));
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -19004,7 +19666,7 @@ class BacktestMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$h(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$i(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -19066,7 +19728,7 @@ class BacktestMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$g = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$h = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -19083,7 +19745,7 @@ const CREATE_KEY_FN$g = (symbol, strategyName, exchangeName, frameName, backtest
  * @param timestamp - Unix timestamp in milliseconds
  * @returns Filename string
  */
-const CREATE_FILE_NAME_FN$9 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$a = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -19112,12 +19774,12 @@ function isUnsafe$2(value) {
     return false;
 }
 /** Maximum number of events to store in live trading reports */
-const MAX_EVENTS$8 = 250;
+const MAX_EVENTS$9 = 250;
 /**
  * Storage class for accumulating all tick events per strategy.
  * Maintains a chronological list of all events (idle, opened, active, closed).
  */
-let ReportStorage$7 = class ReportStorage {
+let ReportStorage$8 = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -19149,7 +19811,7 @@ let ReportStorage$7 = class ReportStorage {
         }
         {
             this._eventList.unshift(newEvent);
-            if (this._eventList.length > MAX_EVENTS$8) {
+            if (this._eventList.length > MAX_EVENTS$9) {
                 this._eventList.pop();
             }
         }
@@ -19179,7 +19841,7 @@ let ReportStorage$7 = class ReportStorage {
             scheduledAt: data.signal.scheduledAt,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$8) {
+        if (this._eventList.length > MAX_EVENTS$9) {
             this._eventList.pop();
         }
     }
@@ -19223,7 +19885,7 @@ let ReportStorage$7 = class ReportStorage {
         // If no previous active event found, add new event
         this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$8) {
+        if (this._eventList.length > MAX_EVENTS$9) {
             this._eventList.pop();
         }
     }
@@ -19260,7 +19922,7 @@ let ReportStorage$7 = class ReportStorage {
         };
         this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$8) {
+        if (this._eventList.length > MAX_EVENTS$9) {
             this._eventList.pop();
         }
     }
@@ -19288,7 +19950,7 @@ let ReportStorage$7 = class ReportStorage {
             scheduledAt: data.signal.scheduledAt,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$8) {
+        if (this._eventList.length > MAX_EVENTS$9) {
             this._eventList.pop();
         }
     }
@@ -19331,7 +19993,7 @@ let ReportStorage$7 = class ReportStorage {
         // If no previous waiting event found, add new event
         this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$8) {
+        if (this._eventList.length > MAX_EVENTS$9) {
             this._eventList.pop();
         }
     }
@@ -19360,7 +20022,7 @@ let ReportStorage$7 = class ReportStorage {
             scheduledAt: data.signal.scheduledAt,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$8) {
+        if (this._eventList.length > MAX_EVENTS$9) {
             this._eventList.pop();
         }
     }
@@ -19499,7 +20161,7 @@ let ReportStorage$7 = class ReportStorage {
     async dump(strategyName, path = "./dump/live", columns = COLUMN_CONFIG.live_columns) {
         const markdown = await this.getReport(strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$9(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$a(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("live", markdown, {
             path,
             signalId: "",
@@ -19549,7 +20211,7 @@ class LiveMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$g(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$7(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$h(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$8(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to live signal emitter to receive tick events.
          * Protected against multiple subscriptions.
@@ -19767,7 +20429,7 @@ class LiveMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$g(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$h(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -19787,7 +20449,7 @@ class LiveMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$f = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$g = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -19804,7 +20466,7 @@ const CREATE_KEY_FN$f = (symbol, strategyName, exchangeName, frameName, backtest
  * @param timestamp - Unix timestamp in milliseconds
  * @returns Filename string
  */
-const CREATE_FILE_NAME_FN$8 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$9 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -19815,12 +20477,12 @@ const CREATE_FILE_NAME_FN$8 = (symbol, strategyName, exchangeName, frameName, ti
     return `${parts.join("_")}-${timestamp}.md`;
 };
 /** Maximum number of events to store in schedule reports */
-const MAX_EVENTS$7 = 250;
+const MAX_EVENTS$8 = 250;
 /**
  * Storage class for accumulating scheduled signal events per strategy.
  * Maintains a chronological list of scheduled and cancelled events.
  */
-let ReportStorage$6 = class ReportStorage {
+let ReportStorage$7 = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -19856,7 +20518,7 @@ let ReportStorage$6 = class ReportStorage {
             scheduledAt: data.signal.scheduledAt,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$7) {
+        if (this._eventList.length > MAX_EVENTS$8) {
             this._eventList.pop();
         }
     }
@@ -19892,7 +20554,7 @@ let ReportStorage$6 = class ReportStorage {
         };
         this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$7) {
+        if (this._eventList.length > MAX_EVENTS$8) {
             this._eventList.pop();
         }
     }
@@ -19930,7 +20592,7 @@ let ReportStorage$6 = class ReportStorage {
         };
         this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$7) {
+        if (this._eventList.length > MAX_EVENTS$8) {
             this._eventList.pop();
         }
     }
@@ -20037,7 +20699,7 @@ let ReportStorage$6 = class ReportStorage {
     async dump(strategyName, path = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) {
         const markdown = await this.getReport(strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$8(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$9(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("schedule", markdown, {
             path,
             file: filename,
@@ -20078,7 +20740,7 @@ class ScheduleMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$f(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$6(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$g(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$7(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to signal emitter to receive scheduled signal events.
          * Protected against multiple subscriptions.
@@ -20281,7 +20943,7 @@ class ScheduleMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$f(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$g(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -20301,7 +20963,7 @@ class ScheduleMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$e = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$f = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -20318,7 +20980,7 @@ const CREATE_KEY_FN$e = (symbol, strategyName, exchangeName, frameName, backtest
  * @param timestamp - Unix timestamp in milliseconds
  * @returns Filename string
  */
-const CREATE_FILE_NAME_FN$7 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$8 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -20338,7 +21000,7 @@ function percentile(sortedArray, p) {
     return sortedArray[Math.max(0, index)];
 }
 /** Maximum number of performance events to store per strategy */
-const MAX_EVENTS$6 = 10000;
+const MAX_EVENTS$7 = 10000;
 /**
  * Storage class for accumulating performance metrics per strategy.
  * Maintains a list of all performance events and provides aggregated statistics.
@@ -20360,7 +21022,7 @@ class PerformanceStorage {
     addEvent(event) {
         this._events.unshift(event);
         // Trim queue if exceeded MAX_EVENTS (keep most recent)
-        if (this._events.length > MAX_EVENTS$6) {
+        if (this._events.length > MAX_EVENTS$7) {
             this._events.pop();
         }
     }
@@ -20477,6 +21139,10 @@ class PerformanceStorage {
         return [
             `# Performance Report: ${strategyName}`,
             "",
+            summaryTable,
+            "",
+            "**Note:** All durations are in milliseconds. P95/P99 represent 95th and 99th percentile response times. Wait times show the interval between consecutive events of the same type.",
+            "",
             `**Total events:** ${stats.totalEvents}`,
             `**Total execution time:** ${stats.totalDuration.toFixed(2)}ms`,
             `**Number of metric types:** ${Object.keys(stats.metricStats).length}`,
@@ -20485,11 +21151,6 @@ class PerformanceStorage {
             "",
             percentages.join("\n"),
             "",
-            "## Detailed Metrics",
-            "",
-            summaryTable,
-            "",
-            "**Note:** All durations are in milliseconds. P95/P99 represent 95th and 99th percentile response times. Wait times show the interval between consecutive events of the same type."
         ].join("\n");
     }
     /**
@@ -20502,7 +21163,7 @@ class PerformanceStorage {
     async dump(strategyName, path = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) {
         const markdown = await this.getReport(strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$7(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$8(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("performance", markdown, {
             path,
             file: filename,
@@ -20549,7 +21210,7 @@ class PerformanceMarkdownService {
          * Memoized function to get or create PerformanceStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$e(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new PerformanceStorage(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$f(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new PerformanceStorage(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to performance emitter to receive performance events.
          * Protected against multiple subscriptions.
@@ -20716,7 +21377,7 @@ class PerformanceMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$e(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$f(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -20730,7 +21391,7 @@ class PerformanceMarkdownService {
  * Creates a filename for markdown report based on walker name.
  * Filename format: "walkerName-timestamp.md"
  */
-const CREATE_FILE_NAME_FN$6 = (walkerName, timestamp) => {
+const CREATE_FILE_NAME_FN$7 = (walkerName, timestamp) => {
     return `${walkerName}-${timestamp}.md`;
 };
 /**
@@ -20765,7 +21426,7 @@ function formatMetric(value) {
  * Storage class for accumulating walker results.
  * Maintains a list of all strategy results and provides methods to generate reports.
  */
-let ReportStorage$5 = class ReportStorage {
+let ReportStorage$6 = class ReportStorage {
     constructor(walkerName) {
         this.walkerName = walkerName;
         /** Walker metadata (set from first addResult call) */
@@ -20953,7 +21614,7 @@ let ReportStorage$5 = class ReportStorage {
     async dump(symbol, metric, context, path = "./dump/walker", strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) {
         const markdown = await this.getReport(symbol, metric, context, strategyColumns, pnlColumns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$6(this.walkerName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$7(this.walkerName, timestamp);
         await Markdown.writeData("walker", markdown, {
             path,
             file: filename,
@@ -20989,7 +21650,7 @@ class WalkerMarkdownService {
          * Memoized function to get or create ReportStorage for a walker.
          * Each walker gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$5(walkerName));
+        this.getStorage = memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$6(walkerName));
         /**
          * Subscribes to walker emitter to receive walker progress events.
          * Protected against multiple subscriptions.
@@ -21186,7 +21847,7 @@ class WalkerMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$d = (exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$e = (exchangeName, frameName, backtest) => {
     const parts = [exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -21197,7 +21858,7 @@ const CREATE_KEY_FN$d = (exchangeName, frameName, backtest) => {
  * Creates a filename for markdown report based on memoization key components.
  * Filename format: "strategyName_exchangeName_frameName-timestamp.md"
  */
-const CREATE_FILE_NAME_FN$5 = (strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$6 = (strategyName, exchangeName, frameName, timestamp) => {
     const parts = [strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -21230,7 +21891,7 @@ function isUnsafe(value) {
     return false;
 }
 /** Maximum number of signals to store per symbol in heatmap reports */
-const MAX_EVENTS$5 = 250;
+const MAX_EVENTS$6 = 250;
 /**
  * Storage class for accumulating closed signals per strategy and generating heatmap.
  * Maintains symbol-level statistics and provides portfolio-wide metrics.
@@ -21256,7 +21917,7 @@ class HeatmapStorage {
         const signals = this.symbolData.get(symbol);
         signals.unshift(data);
         // Trim queue if exceeded MAX_EVENTS per symbol
-        if (signals.length > MAX_EVENTS$5) {
+        if (signals.length > MAX_EVENTS$6) {
             signals.pop();
         }
     }
@@ -21507,7 +22168,7 @@ class HeatmapStorage {
     async dump(strategyName, path = "./dump/heatmap", columns = COLUMN_CONFIG.heat_columns) {
         const markdown = await this.getReport(strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$5(strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$6(strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("heat", markdown, {
             path,
             file: filename,
@@ -21553,7 +22214,7 @@ class HeatMarkdownService {
          * Memoized function to get or create HeatmapStorage for exchange, frame and backtest mode.
          * Each exchangeName + frameName + backtest mode combination gets its own isolated heatmap storage instance.
          */
-        this.getStorage = memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$d(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
+        this.getStorage = memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$e(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
         /**
          * Subscribes to signal emitter to receive tick events.
          * Protected against multiple subscriptions.
@@ -21748,7 +22409,7 @@ class HeatMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$d(payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$e(payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -22779,7 +23440,7 @@ class ClientPartial {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$c = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$d = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
 /**
  * Creates a callback function for emitting profit events to partialProfitSubject.
  *
@@ -22901,7 +23562,7 @@ class PartialConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientPartial instance with logger and event emitters
          */
-        this.getPartial = memoize(([signalId, backtest]) => CREATE_KEY_FN$c(signalId, backtest), (signalId, backtest) => {
+        this.getPartial = memoize(([signalId, backtest]) => CREATE_KEY_FN$d(signalId, backtest), (signalId, backtest) => {
             return new ClientPartial({
                 signalId,
                 logger: this.loggerService,
@@ -22991,7 +23652,7 @@ class PartialConnectionService {
             const partial = this.getPartial(data.id, backtest);
             await partial.waitForInit(symbol, data.strategyName, data.exchangeName, backtest);
             await partial.clear(symbol, data, priceClose, backtest);
-            const key = CREATE_KEY_FN$c(data.id, backtest);
+            const key = CREATE_KEY_FN$d(data.id, backtest);
             this.getPartial.clear(key);
         };
     }
@@ -23007,7 +23668,7 @@ class PartialConnectionService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$b = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$c = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -23018,7 +23679,7 @@ const CREATE_KEY_FN$b = (symbol, strategyName, exchangeName, frameName, backtest
  * Creates a filename for markdown report based on memoization key components.
  * Filename format: "symbol_strategyName_exchangeName_frameName-timestamp.md"
  */
-const CREATE_FILE_NAME_FN$4 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$5 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -23029,12 +23690,12 @@ const CREATE_FILE_NAME_FN$4 = (symbol, strategyName, exchangeName, frameName, ti
     return `${parts.join("_")}-${timestamp}.md`;
 };
 /** Maximum number of events to store in partial reports */
-const MAX_EVENTS$4 = 250;
+const MAX_EVENTS$5 = 250;
 /**
  * Storage class for accumulating partial profit/loss events per symbol-strategy pair.
  * Maintains a chronological list of profit and loss level events.
  */
-let ReportStorage$4 = class ReportStorage {
+let ReportStorage$5 = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -23077,7 +23738,7 @@ let ReportStorage$4 = class ReportStorage {
             backtest,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$4) {
+        if (this._eventList.length > MAX_EVENTS$5) {
             this._eventList.pop();
         }
     }
@@ -23115,7 +23776,7 @@ let ReportStorage$4 = class ReportStorage {
             backtest,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$4) {
+        if (this._eventList.length > MAX_EVENTS$5) {
             this._eventList.pop();
         }
     }
@@ -23191,7 +23852,7 @@ let ReportStorage$4 = class ReportStorage {
     async dump(symbol, strategyName, path = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$4(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$5(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("partial", markdown, {
             path,
             file: filename,
@@ -23232,7 +23893,7 @@ class PartialMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$b(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$4(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$c(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$5(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to partial profit/loss signal emitters to receive events.
          * Protected against multiple subscriptions.
@@ -23442,7 +24103,7 @@ class PartialMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$b(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$c(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -23458,7 +24119,7 @@ class PartialMarkdownService {
  * @param context - Context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$a = (context) => {
+const CREATE_KEY_FN$b = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -23532,7 +24193,7 @@ class PartialGlobalService {
          * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$a(context), (context, methodName) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$b(context), (context, methodName) => {
             this.loggerService.log("partialGlobalService validate", {
                 context,
                 methodName,
@@ -23987,7 +24648,7 @@ class ClientBreakeven {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$9 = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$a = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
 /**
  * Creates a callback function for emitting breakeven events to breakevenSubject.
  *
@@ -24073,7 +24734,7 @@ class BreakevenConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientBreakeven instance with logger and event emitter
          */
-        this.getBreakeven = memoize(([signalId, backtest]) => CREATE_KEY_FN$9(signalId, backtest), (signalId, backtest) => {
+        this.getBreakeven = memoize(([signalId, backtest]) => CREATE_KEY_FN$a(signalId, backtest), (signalId, backtest) => {
             return new ClientBreakeven({
                 signalId,
                 logger: this.loggerService,
@@ -24134,7 +24795,7 @@ class BreakevenConnectionService {
             const breakeven = this.getBreakeven(data.id, backtest);
             await breakeven.waitForInit(symbol, data.strategyName, data.exchangeName, backtest);
             await breakeven.clear(symbol, data, priceClose, backtest);
-            const key = CREATE_KEY_FN$9(data.id, backtest);
+            const key = CREATE_KEY_FN$a(data.id, backtest);
             this.getBreakeven.clear(key);
         };
     }
@@ -24150,7 +24811,7 @@ class BreakevenConnectionService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$8 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$9 = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -24161,7 +24822,7 @@ const CREATE_KEY_FN$8 = (symbol, strategyName, exchangeName, frameName, backtest
  * Creates a filename for markdown report based on memoization key components.
  * Filename format: "symbol_strategyName_exchangeName_frameName-timestamp.md"
  */
-const CREATE_FILE_NAME_FN$3 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$4 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -24172,12 +24833,12 @@ const CREATE_FILE_NAME_FN$3 = (symbol, strategyName, exchangeName, frameName, ti
     return `${parts.join("_")}-${timestamp}.md`;
 };
 /** Maximum number of events to store in breakeven reports */
-const MAX_EVENTS$3 = 250;
+const MAX_EVENTS$4 = 250;
 /**
  * Storage class for accumulating breakeven events per symbol-strategy pair.
  * Maintains a chronological list of breakeven events.
  */
-let ReportStorage$3 = class ReportStorage {
+let ReportStorage$4 = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -24218,7 +24879,7 @@ let ReportStorage$3 = class ReportStorage {
             backtest,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$3) {
+        if (this._eventList.length > MAX_EVENTS$4) {
             this._eventList.pop();
         }
     }
@@ -24286,7 +24947,7 @@ let ReportStorage$3 = class ReportStorage {
     async dump(symbol, strategyName, path = "./dump/breakeven", columns = COLUMN_CONFIG.breakeven_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$3(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$4(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("breakeven", markdown, {
             path,
             file: filename,
@@ -24327,7 +24988,7 @@ class BreakevenMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$8(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$3(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$9(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$4(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to breakeven signal emitter to receive events.
          * Protected against multiple subscriptions.
@@ -24516,7 +25177,7 @@ class BreakevenMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$8(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$9(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -24532,7 +25193,7 @@ class BreakevenMarkdownService {
  * @param context - Context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$7 = (context) => {
+const CREATE_KEY_FN$8 = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -24606,7 +25267,7 @@ class BreakevenGlobalService {
          * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$7(context), (context, methodName) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$8(context), (context, methodName) => {
             this.loggerService.log("breakevenGlobalService validate", {
                 context,
                 methodName,
@@ -24826,7 +25487,7 @@ class ConfigValidationService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$6 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$7 = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -24837,7 +25498,7 @@ const CREATE_KEY_FN$6 = (symbol, strategyName, exchangeName, frameName, backtest
  * Creates a filename for markdown report based on memoization key components.
  * Filename format: "symbol_strategyName_exchangeName_frameName-timestamp.md"
  */
-const CREATE_FILE_NAME_FN$2 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$3 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -24848,12 +25509,12 @@ const CREATE_FILE_NAME_FN$2 = (symbol, strategyName, exchangeName, frameName, ti
     return `${parts.join("_")}-${timestamp}.md`;
 };
 /** Maximum number of events to store in risk reports */
-const MAX_EVENTS$2 = 250;
+const MAX_EVENTS$3 = 250;
 /**
  * Storage class for accumulating risk rejection events per symbol-strategy pair.
  * Maintains a chronological list of rejected signals due to risk limits.
  */
-let ReportStorage$2 = class ReportStorage {
+let ReportStorage$3 = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -24870,7 +25531,7 @@ let ReportStorage$2 = class ReportStorage {
     addRejectionEvent(event) {
         this._eventList.unshift(event);
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$2) {
+        if (this._eventList.length > MAX_EVENTS$3) {
             this._eventList.pop();
         }
     }
@@ -24954,7 +25615,7 @@ let ReportStorage$2 = class ReportStorage {
     async dump(symbol, strategyName, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$2(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$3(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("risk", markdown, {
             path,
             file: filename,
@@ -24995,7 +25656,7 @@ class RiskMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$2(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$7(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$3(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to risk rejection emitter to receive rejection events.
          * Protected against multiple subscriptions.
@@ -25184,7 +25845,7 @@ class RiskMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$6(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$7(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -25482,6 +26143,7 @@ const WILDCARD_TARGET = {
     schedule: true,
     walker: true,
     sync: true,
+    highest_profit: true,
 };
 /**
  * Utility class for managing report services.
@@ -25519,7 +26181,7 @@ class ReportUtils {
          *
          * @returns Cleanup function that unsubscribes from all enabled services
          */
-        this.enable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, strategy = false, sync = false, } = WILDCARD_TARGET) => {
+        this.enable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, strategy = false, sync = false, highest_profit = false, } = WILDCARD_TARGET) => {
             bt.loggerService.debug(REPORT_UTILS_METHOD_NAME_ENABLE, {
                 backtest: bt$1,
                 breakeven,
@@ -25567,6 +26229,9 @@ class ReportUtils {
             if (sync) {
                 unList.push(bt.syncReportService.subscribe());
             }
+            if (highest_profit) {
+                unList.push(bt.highestProfitReportService.subscribe());
+            }
             return compose(...unList.map((un) => () => void un()));
         };
         /**
@@ -25605,7 +26270,7 @@ class ReportUtils {
          * Report.disable();
          * ```
          */
-        this.disable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, strategy = false, sync = false, } = WILDCARD_TARGET) => {
+        this.disable = ({ backtest: bt$1 = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, strategy = false, sync = false, highest_profit = false, } = WILDCARD_TARGET) => {
             bt.loggerService.debug(REPORT_UTILS_METHOD_NAME_DISABLE, {
                 backtest: bt$1,
                 breakeven,
@@ -25652,6 +26317,9 @@ class ReportUtils {
             if (sync) {
                 bt.syncReportService.unsubscribe();
             }
+            if (highest_profit) {
+                bt.highestProfitReportService.unsubscribe();
+            }
         };
     }
 }
@@ -27859,6 +28527,60 @@ class SyncReportService {
     }
 }
 
+const HIGHEST_PROFIT_REPORT_METHOD_NAME_SUBSCRIBE = "HighestProfitReportService.subscribe";
+const HIGHEST_PROFIT_REPORT_METHOD_NAME_UNSUBSCRIBE = "HighestProfitReportService.unsubscribe";
+const HIGHEST_PROFIT_REPORT_METHOD_NAME_TICK = "HighestProfitReportService.tick";
+/**
+ * Service for logging highest profit events to the JSONL report database.
+ *
+ * Listens to highestProfitSubject and writes each new price record to
+ * Report.writeData() for persistence and analytics.
+ */
+class HighestProfitReportService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.tick = async (data) => {
+            this.loggerService.log(HIGHEST_PROFIT_REPORT_METHOD_NAME_TICK, { data });
+            await Report.writeData("highest_profit", {
+                timestamp: data.timestamp,
+                symbol: data.symbol,
+                strategyName: data.signal.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                backtest: data.backtest,
+                signalId: data.signal.id,
+                position: data.signal.position,
+                currentPrice: data.currentPrice,
+                priceOpen: data.signal.priceOpen,
+                priceTakeProfit: data.signal.priceTakeProfit,
+                priceStopLoss: data.signal.priceStopLoss,
+            }, {
+                symbol: data.symbol,
+                strategyName: data.signal.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName,
+                signalId: data.signal.id,
+                walkerName: "",
+            });
+        };
+        this.subscribe = singleshot(() => {
+            this.loggerService.log(HIGHEST_PROFIT_REPORT_METHOD_NAME_SUBSCRIBE);
+            const unsub = highestProfitSubject.subscribe(this.tick);
+            return () => {
+                this.subscribe.clear();
+                unsub();
+            };
+        });
+        this.unsubscribe = async () => {
+            this.loggerService.log(HIGHEST_PROFIT_REPORT_METHOD_NAME_UNSUBSCRIBE);
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
+    }
+}
+
 /**
  * Creates a unique key for memoizing ReportStorage instances.
  *
@@ -27872,7 +28594,7 @@ class SyncReportService {
  * @returns Colon-separated key string for memoization
  * @internal
  */
-const CREATE_KEY_FN$5 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$6 = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -27892,7 +28614,7 @@ const CREATE_KEY_FN$5 = (symbol, strategyName, exchangeName, frameName, backtest
  * @returns Underscore-separated filename with .md extension
  * @internal
  */
-const CREATE_FILE_NAME_FN$1 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$2 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -27907,7 +28629,7 @@ const CREATE_FILE_NAME_FN$1 = (symbol, strategyName, exchangeName, frameName, ti
  * Older events are discarded when this limit is exceeded.
  * @internal
  */
-const MAX_EVENTS$1 = 250;
+const MAX_EVENTS$2 = 250;
 /**
  * In-memory storage for accumulating strategy events per symbol-strategy pair.
  *
@@ -27920,7 +28642,7 @@ const MAX_EVENTS$1 = 250;
  *
  * @internal
  */
-let ReportStorage$1 = class ReportStorage {
+let ReportStorage$2 = class ReportStorage {
     /**
      * Creates a new ReportStorage instance.
      *
@@ -27946,7 +28668,7 @@ let ReportStorage$1 = class ReportStorage {
      */
     addEvent(event) {
         this._eventList.unshift(event);
-        if (this._eventList.length > MAX_EVENTS$1) {
+        if (this._eventList.length > MAX_EVENTS$2) {
             this._eventList.pop();
         }
     }
@@ -28051,7 +28773,7 @@ let ReportStorage$1 = class ReportStorage {
     async dump(symbol, strategyName, path = "./dump/strategy", columns = COLUMN_CONFIG.strategy_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN$1(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$2(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("strategy", markdown, {
             path,
             file: filename,
@@ -28120,7 +28842,7 @@ class StrategyMarkdownService {
          *
          * @internal
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$5(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$1(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$2(symbol, strategyName, exchangeName, frameName));
         /**
          * Records a cancel-scheduled event when a scheduled signal is cancelled.
          *
@@ -28688,7 +29410,7 @@ class StrategyMarkdownService {
         this.clear = async (payload) => {
             this.loggerService.log("strategyMarkdownService clear", { payload });
             if (payload) {
-                const key = CREATE_KEY_FN$5(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$6(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -28796,7 +29518,7 @@ class StrategyMarkdownService {
  * Creates a unique key for memoizing ReportStorage instances.
  * Key format: "symbol:strategyName:exchangeName[:frameName]:backtest|live"
  */
-const CREATE_KEY_FN$4 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$5 = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -28807,7 +29529,7 @@ const CREATE_KEY_FN$4 = (symbol, strategyName, exchangeName, frameName, backtest
  * Creates a filename for the markdown report.
  * Filename format: "symbol_strategyName_exchangeName[_frameName_backtest|_live]-timestamp.md"
  */
-const CREATE_FILE_NAME_FN = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+const CREATE_FILE_NAME_FN$1 = (symbol, strategyName, exchangeName, frameName, timestamp) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName) {
         parts.push(frameName);
@@ -28818,12 +29540,12 @@ const CREATE_FILE_NAME_FN = (symbol, strategyName, exchangeName, frameName, time
     return `${parts.join("_")}-${timestamp}.md`;
 };
 /** Maximum number of events to store in sync reports */
-const MAX_EVENTS = 250;
+const MAX_EVENTS$1 = 250;
 /**
  * Storage class for accumulating signal sync events per symbol-strategy-exchange-frame-backtest combination.
  * Maintains a chronological list of signal-open and signal-close events.
  */
-class ReportStorage {
+let ReportStorage$1 = class ReportStorage {
     constructor(symbol, strategyName, exchangeName, frameName) {
         this.symbol = symbol;
         this.strategyName = strategyName;
@@ -28833,7 +29555,7 @@ class ReportStorage {
     }
     addEvent(event) {
         this._eventList.unshift(event);
-        if (this._eventList.length > MAX_EVENTS) {
+        if (this._eventList.length > MAX_EVENTS$1) {
             this._eventList.pop();
         }
     }
@@ -28894,7 +29616,7 @@ class ReportStorage {
     async dump(symbol, strategyName, path = "./dump/sync", columns = COLUMN_CONFIG.sync_columns) {
         const markdown = await this.getReport(symbol, strategyName, columns);
         const timestamp = getContextTimestamp();
-        const filename = CREATE_FILE_NAME_FN(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        const filename = CREATE_FILE_NAME_FN$1(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
         await Markdown.writeData("sync", markdown, {
             path,
             file: filename,
@@ -28905,7 +29627,7 @@ class ReportStorage {
             frameName: this.frameName,
         });
     }
-}
+};
 /**
  * Service for generating and saving signal sync markdown reports.
  *
@@ -28928,7 +29650,7 @@ class ReportStorage {
 class SyncMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$4(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$5(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$1(symbol, strategyName, exchangeName, frameName));
         this.subscribe = singleshot(() => {
             this.loggerService.log("syncMarkdownService init");
             const unsubscribe = syncSubject.subscribe(this.tick);
@@ -29002,6 +29724,190 @@ class SyncMarkdownService {
         };
         this.clear = async (payload) => {
             this.loggerService.log("syncMarkdownService clear", { payload });
+            if (payload) {
+                const key = CREATE_KEY_FN$5(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                this.getStorage.clear(key);
+            }
+            else {
+                this.getStorage.clear();
+            }
+        };
+    }
+}
+
+/**
+ * Creates a unique memoization key for a symbol-strategy-exchange-frame-backtest combination.
+ */
+const CREATE_KEY_FN$4 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
+/**
+ * Creates a filename for the markdown report.
+ */
+const CREATE_FILE_NAME_FN = (symbol, strategyName, exchangeName, frameName, timestamp) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName) {
+        parts.push(frameName);
+        parts.push("backtest");
+    }
+    else
+        parts.push("live");
+    return `${parts.join("_")}-${timestamp}.md`;
+};
+/** Maximum number of events to store per combination */
+const MAX_EVENTS = 250;
+/**
+ * Accumulates highest profit events per symbol-strategy-exchange-frame combination.
+ */
+class ReportStorage {
+    constructor(symbol, strategyName, exchangeName, frameName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
+        this._eventList = [];
+    }
+    /**
+     * Adds a highest profit event to the storage.
+     */
+    addEvent(data, currentPrice, backtest, timestamp) {
+        this._eventList.unshift({
+            timestamp,
+            symbol: data.symbol,
+            strategyName: data.strategyName,
+            signalId: data.id,
+            position: data.position,
+            pnl: data.pnl,
+            currentPrice,
+            priceOpen: data.priceOpen,
+            priceTakeProfit: data.priceTakeProfit,
+            priceStopLoss: data.priceStopLoss,
+            backtest,
+        });
+        if (this._eventList.length > MAX_EVENTS) {
+            this._eventList.pop();
+        }
+    }
+    /**
+     * Returns aggregated statistics from accumulated events.
+     */
+    async getData() {
+        return {
+            eventList: this._eventList,
+            totalEvents: this._eventList.length,
+        };
+    }
+    /**
+     * Generates a markdown report table for this storage.
+     */
+    async getReport(symbol, strategyName, columns = COLUMN_CONFIG.highest_profit_columns) {
+        const stats = await this.getData();
+        if (stats.totalEvents === 0) {
+            return [
+                `# Highest Profit Report: ${symbol}:${strategyName}`,
+                "",
+                "No highest profit events recorded yet.",
+            ].join("\n");
+        }
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
+        const header = visibleColumns.map((col) => col.label);
+        const separator = visibleColumns.map(() => "---");
+        const rows = await Promise.all(this._eventList.map(async (event, index) => Promise.all(visibleColumns.map((col) => col.format(event, index)))));
+        const tableData = [header, separator, ...rows];
+        const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
+        return [
+            `# Highest Profit Report: ${symbol}:${strategyName}`,
+            "",
+            table,
+            "",
+            `**Total events:** ${stats.totalEvents}`,
+        ].join("\n");
+    }
+    /**
+     * Saves the report to disk.
+     */
+    async dump(symbol, strategyName, path = "./dump/highest_profit", columns = COLUMN_CONFIG.highest_profit_columns) {
+        const markdown = await this.getReport(symbol, strategyName, columns);
+        const timestamp = getContextTimestamp();
+        const filename = CREATE_FILE_NAME_FN(this.symbol, strategyName, this.exchangeName, this.frameName, timestamp);
+        await Markdown.writeData("highest_profit", markdown, {
+            path,
+            file: filename,
+            symbol: this.symbol,
+            signalId: "",
+            strategyName: this.strategyName,
+            exchangeName: this.exchangeName,
+            frameName: this.frameName,
+        });
+    }
+}
+/**
+ * Service for generating and saving highest profit markdown reports.
+ *
+ * Listens to highestProfitSubject and accumulates events per
+ * symbol-strategy-exchange-frame combination. Provides getData(),
+ * getReport(), and dump() methods matching the Partial pattern.
+ */
+class HighestProfitMarkdownService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$4(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage(symbol, strategyName, exchangeName, frameName));
+        this.subscribe = singleshot(() => {
+            this.loggerService.log("highestProfitMarkdownService init");
+            const unsub = highestProfitSubject.subscribe(this.tick);
+            return () => {
+                this.subscribe.clear();
+                this.clear();
+                unsub();
+            };
+        });
+        this.unsubscribe = async () => {
+            this.loggerService.log("highestProfitMarkdownService unsubscribe");
+            if (this.subscribe.hasValue()) {
+                const lastSubscription = this.subscribe();
+                lastSubscription();
+            }
+        };
+        this.tick = async (data) => {
+            this.loggerService.log("highestProfitMarkdownService tick", { data });
+            const storage = this.getStorage(data.symbol, data.signal.strategyName, data.exchangeName, data.frameName, data.backtest);
+            storage.addEvent(data.signal, data.currentPrice, data.backtest, data.timestamp);
+        };
+        this.getData = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            this.loggerService.log("highestProfitMarkdownService getData", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("HighestProfitMarkdownService not initialized. Call subscribe() before getting data.");
+            }
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
+            return storage.getData();
+        };
+        this.getReport = async (symbol, strategyName, exchangeName, frameName, backtest, columns = COLUMN_CONFIG.highest_profit_columns) => {
+            this.loggerService.log("highestProfitMarkdownService getReport", { symbol, strategyName, exchangeName, frameName, backtest });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("HighestProfitMarkdownService not initialized. Call subscribe() before generating reports.");
+            }
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
+            return storage.getReport(symbol, strategyName, columns);
+        };
+        this.dump = async (symbol, strategyName, exchangeName, frameName, backtest, path = "./dump/highest_profit", columns = COLUMN_CONFIG.highest_profit_columns) => {
+            this.loggerService.log("highestProfitMarkdownService dump", { symbol, strategyName, exchangeName, frameName, backtest, path });
+            if (!this.subscribe.hasValue()) {
+                throw new Error("HighestProfitMarkdownService not initialized. Call subscribe() before dumping reports.");
+            }
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
+            await storage.dump(symbol, strategyName, path, columns);
+        };
+        this.clear = async (payload) => {
+            this.loggerService.log("highestProfitMarkdownService clear", { payload });
             if (payload) {
                 const key = CREATE_KEY_FN$4(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
@@ -29351,6 +30257,7 @@ class TimeMetaService {
     provide(TYPES.riskMarkdownService, () => new RiskMarkdownService());
     provide(TYPES.strategyMarkdownService, () => new StrategyMarkdownService());
     provide(TYPES.syncMarkdownService, () => new SyncMarkdownService());
+    provide(TYPES.highestProfitMarkdownService, () => new HighestProfitMarkdownService());
 }
 {
     provide(TYPES.backtestReportService, () => new BacktestReportService());
@@ -29364,6 +30271,7 @@ class TimeMetaService {
     provide(TYPES.riskReportService, () => new RiskReportService());
     provide(TYPES.strategyReportService, () => new StrategyReportService());
     provide(TYPES.syncReportService, () => new SyncReportService());
+    provide(TYPES.highestProfitReportService, () => new HighestProfitReportService());
 }
 {
     provide(TYPES.exchangeValidationService, () => new ExchangeValidationService());
@@ -29446,6 +30354,7 @@ const markdownServices = {
     riskMarkdownService: inject(TYPES.riskMarkdownService),
     strategyMarkdownService: inject(TYPES.strategyMarkdownService),
     syncMarkdownService: inject(TYPES.syncMarkdownService),
+    highestProfitMarkdownService: inject(TYPES.highestProfitMarkdownService),
 };
 const reportServices = {
     backtestReportService: inject(TYPES.backtestReportService),
@@ -29459,6 +30368,7 @@ const reportServices = {
     riskReportService: inject(TYPES.riskReportService),
     strategyReportService: inject(TYPES.strategyReportService),
     syncReportService: inject(TYPES.syncReportService),
+    highestProfitReportService: inject(TYPES.highestProfitReportService),
 };
 const validationServices = {
     exchangeValidationService: inject(TYPES.exchangeValidationService),
@@ -31230,7 +32140,7 @@ const investedCostToPercent = (dollarAmount, investedCost) => {
  *
  * @param newStopLossPrice - Desired absolute stop-loss price
  * @param originalStopLossPrice - Original stop-loss price from the pending signal
- * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @param effectivePriceOpen - Effective entry price (from `getPositionEffectivePrice`)
  * @returns percentShift to pass to `commitTrailingStop`
  *
  * @example
@@ -31252,7 +32162,7 @@ const slPriceToPercentShift = (newStopLossPrice, originalStopLossPrice, effectiv
  *
  * @param newTakeProfitPrice - Desired absolute take-profit price
  * @param originalTakeProfitPrice - Original take-profit price from the pending signal
- * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @param effectivePriceOpen - Effective entry price (from `getPositionEffectivePrice`)
  * @returns percentShift to pass to `commitTrailingTake`
  *
  * @example
@@ -31277,7 +32187,7 @@ const tpPriceToPercentShift = (newTakeProfitPrice, originalTakeProfitPrice, effe
  *
  * @param percentShift - Value returned by `slPriceToPercentShift` (or passed to `commitTrailingStop`)
  * @param originalStopLossPrice - Original stop-loss price from the pending signal
- * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @param effectivePriceOpen - Effective entry price (from `getPositionEffectivePrice`)
  * @param position - Position direction: "long" or "short"
  * @returns Absolute stop-loss price corresponding to the given percentShift
  *
@@ -31304,7 +32214,7 @@ const slPercentShiftToPrice = (percentShift, originalStopLossPrice, effectivePri
  *
  * @param percentShift - Value returned by `tpPriceToPercentShift` (or passed to `commitTrailingTake`)
  * @param originalTakeProfitPrice - Original take-profit price from the pending signal
- * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @param effectivePriceOpen - Effective entry price (from `getPositionEffectivePrice`)
  * @param position - Position direction: "long" or "short"
  * @returns Absolute take-profit price corresponding to the given percentShift
  *
@@ -31343,7 +32253,7 @@ const percentToCloseCost = (percentToClose, investedCost) => {
  * Breakeven moves the SL to the effective entry price (effectivePriceOpen).
  * The value is the same regardless of position direction.
  *
- * @param effectivePriceOpen - Effective entry price (from `getPositionAveragePrice`)
+ * @param effectivePriceOpen - Effective entry price (from `getPositionEffectivePrice`)
  * @returns New stop-loss price equal to the effective entry price
  *
  * @example
@@ -32265,13 +33175,22 @@ const GET_TOTAL_COST_CLOSED_METHOD_NAME = "strategy.getTotalCostClosed";
 const GET_PENDING_SIGNAL_METHOD_NAME = "strategy.getPendingSignal";
 const GET_SCHEDULED_SIGNAL_METHOD_NAME = "strategy.getScheduledSignal";
 const GET_BREAKEVEN_METHOD_NAME = "strategy.getBreakeven";
-const GET_POSITION_AVERAGE_PRICE_METHOD_NAME = "strategy.getPositionAveragePrice";
+const GET_POSITION_AVERAGE_PRICE_METHOD_NAME = "strategy.getPositionEffectivePrice";
 const GET_POSITION_INVESTED_COUNT_METHOD_NAME = "strategy.getPositionInvestedCount";
 const GET_POSITION_INVESTED_COST_METHOD_NAME = "strategy.getPositionInvestedCost";
 const GET_POSITION_PNL_PERCENT_METHOD_NAME = "strategy.getPositionPnlPercent";
 const GET_POSITION_PNL_COST_METHOD_NAME = "strategy.getPositionPnlCost";
 const GET_POSITION_LEVELS_METHOD_NAME = "strategy.getPositionLevels";
 const GET_POSITION_PARTIALS_METHOD_NAME = "strategy.getPositionPartials";
+const GET_POSITION_ENTRIES_METHOD_NAME = "strategy.getPositionEntries";
+const GET_POSITION_ESTIMATE_MINUTES_METHOD_NAME = "strategy.getPositionEstimateMinutes";
+const GET_POSITION_COUNTDOWN_MINUTES_METHOD_NAME = "strategy.getPositionCountdownMinutes";
+const GET_POSITION_HIGHEST_PROFIT_PRICE_METHOD_NAME = "strategy.getPositionHighestProfitPrice";
+const GET_POSITION_HIGHEST_PROFIT_TIMESTAMP_METHOD_NAME = "strategy.getPositionHighestProfitTimestamp";
+const GET_POSITION_HIGHEST_PNL_PERCENTAGE_METHOD_NAME = "strategy.getPositionHighestPnlPercentage";
+const GET_POSITION_HIGHEST_PNL_COST_METHOD_NAME = "strategy.getPositionHighestPnlCost";
+const GET_POSITION_HIGHEST_PROFIT_BREAKEVEN_METHOD_NAME = "strategy.getPositionHighestProfitBreakeven";
+const GET_POSITION_DRAWDOWN_MINUTES_METHOD_NAME = "strategy.getPositionDrawdownMinutes";
 const GET_POSITION_ENTRY_OVERLAP_METHOD_NAME = "strategy.getPositionEntryOverlap";
 const GET_POSITION_PARTIAL_OVERLAP_METHOD_NAME = "strategy.getPositionPartialOverlap";
 /**
@@ -32538,7 +33457,7 @@ async function commitTrailingStop(symbol, percentShift, currentPrice) {
     if (!signal) {
         return false;
     }
-    const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
     if (effectivePriceOpen === null) {
         return false;
     }
@@ -32618,7 +33537,7 @@ async function commitTrailingTake(symbol, percentShift, currentPrice) {
     if (!signal) {
         return false;
     }
-    const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
     if (effectivePriceOpen === null) {
         return false;
     }
@@ -32668,7 +33587,7 @@ async function commitTrailingStopCost(symbol, newStopLossPrice) {
     if (!signal) {
         return false;
     }
-    const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
     if (effectivePriceOpen === null) {
         return false;
     }
@@ -32719,7 +33638,7 @@ async function commitTrailingTakeCost(symbol, newTakeProfitPrice) {
     if (!signal) {
         return false;
     }
-    const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
     if (effectivePriceOpen === null) {
         return false;
     }
@@ -32781,7 +33700,7 @@ async function commitBreakeven(symbol) {
     if (!signal) {
         return false;
     }
-    const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
     if (effectivePriceOpen === null) {
         return false;
     }
@@ -33077,26 +33996,26 @@ async function getBreakeven(symbol, currentPrice) {
  *
  * @example
  * ```typescript
- * import { getPositionAveragePrice } from "backtest-kit";
+ * import { getPositionEffectivePrice } from "backtest-kit";
  *
- * const avgPrice = await getPositionAveragePrice("BTCUSDT");
+ * const avgPrice = await getPositionEffectivePrice("BTCUSDT");
  * // No DCA: avgPrice === priceOpen
  * // After DCA at lower price: avgPrice < priceOpen
  * ```
  */
-async function getPositionAveragePrice(symbol) {
+async function getPositionEffectivePrice(symbol) {
     bt.loggerService.info(GET_POSITION_AVERAGE_PRICE_METHOD_NAME, {
         symbol,
     });
     if (!ExecutionContextService.hasContext()) {
-        throw new Error("getPositionAveragePrice requires an execution context");
+        throw new Error("getPositionEffectivePrice requires an execution context");
     }
     if (!MethodContextService.hasContext()) {
-        throw new Error("getPositionAveragePrice requires a method context");
+        throw new Error("getPositionEffectivePrice requires a method context");
     }
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
-    return await bt.strategyCoreService.getPositionAveragePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
+    return await bt.strategyCoreService.getPositionEffectivePrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
 }
 /**
  * Returns the number of DCA entries made for the current pending signal.
@@ -33451,6 +34370,284 @@ async function getPositionPartials(symbol) {
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     return await bt.strategyCoreService.getPositionPartials(isBacktest, symbol, { exchangeName, frameName, strategyName });
 }
+/**
+ * Returns the list of DCA entry prices and costs for the current pending signal.
+ *
+ * Each element represents a single position entry — the initial open or a subsequent
+ * DCA entry added via commitAverageBuy.
+ *
+ * Returns null if no pending signal exists.
+ * Returns a single-element array if no DCA entries were made.
+ *
+ * Each entry contains:
+ * - `price` — execution price of this entry
+ * - `cost` — dollar cost allocated to this entry (e.g. 100 for $100)
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to array of entry records or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionEntries } from "backtest-kit";
+ *
+ * const entries = await getPositionEntries("BTCUSDT");
+ * // No DCA: [{ price: 43000, cost: 100 }]
+ * // One DCA: [{ price: 43000, cost: 100 }, { price: 42000, cost: 100 }]
+ * ```
+ */
+async function getPositionEntries(symbol) {
+    bt.loggerService.info(GET_POSITION_ENTRIES_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionEntries requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionEntries requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionEntries(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the original estimated duration for the current pending signal.
+ *
+ * Reflects `minuteEstimatedTime` as set in the signal DTO — the maximum
+ * number of minutes the position is expected to be active before `time_expired`.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to estimated duration in minutes or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionEstimateMinutes } from "backtest-kit";
+ *
+ * const estimate = await getPositionEstimateMinutes("BTCUSDT");
+ * // e.g. 120 (2 hours)
+ * ```
+ */
+async function getPositionEstimateMinutes(symbol) {
+    bt.loggerService.info(GET_POSITION_ESTIMATE_MINUTES_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionEstimateMinutes requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionEstimateMinutes requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionEstimateMinutes(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the remaining time before the position expires, clamped to zero.
+ *
+ * Computes elapsed minutes since `pendingAt` and subtracts from `minuteEstimatedTime`.
+ * Returns 0 once the estimate is exceeded (never negative).
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to remaining minutes (≥ 0) or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionCountdownMinutes } from "backtest-kit";
+ *
+ * const remaining = await getPositionCountdownMinutes("BTCUSDT");
+ * // e.g. 45 (45 minutes left)
+ * // 0 when expired
+ * ```
+ */
+async function getPositionCountdownMinutes(symbol) {
+    bt.loggerService.info(GET_POSITION_COUNTDOWN_MINUTES_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionCountdownMinutes requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionCountdownMinutes requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionCountdownMinutes(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the best price reached in the profit direction during this position's life.
+ *
+ * Initialized at position open with the entry price and timestamp.
+ * Updated on every tick/candle when VWAP moves beyond the previous record toward TP:
+ * - LONG: tracks the highest price seen above effective entry
+ * - SHORT: tracks the lowest price seen below effective entry
+ *
+ * Returns null if no pending signal exists.
+ * Never returns null when a signal is active — always contains at least the entry price.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to `{ price, timestamp }` record or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestProfitPrice } from "backtest-kit";
+ *
+ * const peak = await getPositionHighestProfitPrice("BTCUSDT");
+ * // e.g. { price: 44500, timestamp: 1700000000000 }
+ * ```
+ */
+async function getPositionHighestProfitPrice(symbol) {
+    bt.loggerService.info(GET_POSITION_HIGHEST_PROFIT_PRICE_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitPrice requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitPrice requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionHighestProfitPrice(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the timestamp when the best profit price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to timestamp in milliseconds or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestProfitTimestamp } from "backtest-kit";
+ *
+ * const ts = await getPositionHighestProfitTimestamp("BTCUSDT");
+ * // e.g. 1700000000000
+ * ```
+ */
+async function getPositionHighestProfitTimestamp(symbol) {
+    bt.loggerService.info(GET_POSITION_HIGHEST_PROFIT_TIMESTAMP_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitTimestamp requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitTimestamp requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionHighestProfitTimestamp(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to PnL percentage or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestPnlPercentage } from "backtest-kit";
+ *
+ * const pnl = await getPositionHighestPnlPercentage("BTCUSDT");
+ * // e.g. 3.5
+ * ```
+ */
+async function getPositionHighestPnlPercentage(symbol) {
+    bt.loggerService.info(GET_POSITION_HIGHEST_PNL_PERCENTAGE_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionHighestPnlPercentage requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionHighestPnlPercentage requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionHighestPnlPercentage(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to PnL cost or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestPnlCost } from "backtest-kit";
+ *
+ * const pnlCost = await getPositionHighestPnlCost("BTCUSDT");
+ * // e.g. 35.5
+ * ```
+ */
+async function getPositionHighestPnlCost(symbol) {
+    bt.loggerService.info(GET_POSITION_HIGHEST_PNL_COST_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionHighestPnlCost requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionHighestPnlCost requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionHighestPnlCost(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns whether breakeven was mathematically reachable at the highest profit price.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to true if breakeven was reachable at peak, false otherwise, or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestProfitBreakeven } from "backtest-kit";
+ *
+ * const couldBreakeven = await getPositionHighestProfitBreakeven("BTCUSDT");
+ * // e.g. true (price reached the breakeven threshold at its peak)
+ * ```
+ */
+async function getPositionHighestProfitBreakeven(symbol) {
+    bt.loggerService.info(GET_POSITION_HIGHEST_PROFIT_BREAKEVEN_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitBreakeven requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitBreakeven requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionHighestProfitBreakeven(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the number of minutes elapsed since the highest profit price was recorded.
+ *
+ * Measures how long the position has been pulling back from its peak profit level.
+ * Zero when called at the exact moment the peak was set.
+ * Grows continuously as price moves away from the peak without setting a new record.
+ *
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to drawdown duration in minutes or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionDrawdownMinutes } from "backtest-kit";
+ *
+ * const drawdown = await getPositionDrawdownMinutes("BTCUSDT");
+ * // e.g. 30 (30 minutes since the highest profit price)
+ * ```
+ */
+async function getPositionDrawdownMinutes(symbol) {
+    bt.loggerService.info(GET_POSITION_DRAWDOWN_MINUTES_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionDrawdownMinutes requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionDrawdownMinutes requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    return await bt.strategyCoreService.getPositionDrawdownMinutes(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
 /**
  * Checks whether the current price falls within the tolerance zone of any existing DCA entry level.
  * Use this to prevent duplicate DCA entries at the same price area.
@@ -33628,6 +34825,8 @@ const LISTEN_STRATEGY_COMMIT_METHOD_NAME = "event.listenStrategyCommit";
 const LISTEN_STRATEGY_COMMIT_ONCE_METHOD_NAME = "event.listenStrategyCommitOnce";
 const LISTEN_SYNC_METHOD_NAME = "event.listenSync";
 const LISTEN_SYNC_ONCE_METHOD_NAME = "event.listenSyncOnce";
+const LISTEN_HIGHEST_PROFIT_METHOD_NAME = "event.listenHighestProfit";
+const LISTEN_HIGHEST_PROFIT_ONCE_METHOD_NAME = "event.listenHighestProfitOnce";
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -34754,6 +35953,33 @@ function listenSyncOnce(filterFn, fn) {
     bt.loggerService.log(LISTEN_SYNC_ONCE_METHOD_NAME);
     return syncSubject.filter(filterFn).once(fn);
 }
+/**
+ * Subscribes to highest profit events with queued async processing.
+ * Emits when a signal reaches a new highest profit level during its lifecycle.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ * Useful for tracking profit milestones and implementing dynamic management logic.
+ *
+ * @param fn - Callback function to handle highest profit events
+ * @return Unsubscribe function to stop listening to events
+ */
+function listenHighestProfit(fn) {
+    bt.loggerService.log(LISTEN_HIGHEST_PROFIT_METHOD_NAME);
+    return highestProfitSubject.subscribe(queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered highest profit events with one-time execution.
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific profit 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
+ */
+function listenHighestProfitOnce(filterFn, fn) {
+    bt.loggerService.log(LISTEN_HIGHEST_PROFIT_ONCE_METHOD_NAME);
+    return highestProfitSubject.filter(filterFn).once(fn);
+}
 
 const BACKTEST_METHOD_NAME_RUN = "BacktestUtils.run";
 const BACKTEST_METHOD_NAME_BACKGROUND = "BacktestUtils.background";
@@ -34767,7 +35993,7 @@ const BACKTEST_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED = "BacktestUtils.getTotalPer
 const BACKTEST_METHOD_NAME_GET_TOTAL_COST_CLOSED = "BacktestUtils.getTotalCostClosed";
 const BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL = "BacktestUtils.getScheduledSignal";
 const BACKTEST_METHOD_NAME_GET_BREAKEVEN = "BacktestUtils.getBreakeven";
-const BACKTEST_METHOD_NAME_GET_POSITION_AVERAGE_PRICE = "BacktestUtils.getPositionAveragePrice";
+const BACKTEST_METHOD_NAME_GET_POSITION_AVERAGE_PRICE = "BacktestUtils.getPositionEffectivePrice";
 const BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COUNT = "BacktestUtils.getPositionInvestedCount";
 const BACKTEST_METHOD_NAME_GET_POSITION_INVESTED_COST = "BacktestUtils.getPositionInvestedCost";
 const BACKTEST_METHOD_NAME_GET_POSITION_PNL_PERCENT = "BacktestUtils.getPositionPnlPercent";
@@ -34775,6 +36001,14 @@ const BACKTEST_METHOD_NAME_GET_POSITION_PNL_COST = "BacktestUtils.getPositionPnl
 const BACKTEST_METHOD_NAME_GET_POSITION_LEVELS = "BacktestUtils.getPositionLevels";
 const BACKTEST_METHOD_NAME_GET_POSITION_PARTIALS = "BacktestUtils.getPositionPartials";
 const BACKTEST_METHOD_NAME_GET_POSITION_ENTRIES = "BacktestUtils.getPositionEntries";
+const BACKTEST_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES = "BacktestUtils.getPositionEstimateMinutes";
+const BACKTEST_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES = "BacktestUtils.getPositionCountdownMinutes";
+const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE = "BacktestUtils.getPositionHighestProfitPrice";
+const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP = "BacktestUtils.getPositionHighestProfitTimestamp";
+const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE = "BacktestUtils.getPositionHighestPnlPercentage";
+const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST = "BacktestUtils.getPositionHighestPnlCost";
+const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN = "BacktestUtils.getPositionHighestProfitBreakeven";
+const BACKTEST_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES = "BacktestUtils.getPositionDrawdownMinutes";
 const BACKTEST_METHOD_NAME_GET_POSITION_ENTRY_OVERLAP = "BacktestUtils.getPositionEntryOverlap";
 const BACKTEST_METHOD_NAME_GET_POSITION_PARTIAL_OVERLAP = "BacktestUtils.getPositionPartialOverlap";
 const BACKTEST_METHOD_NAME_BREAKEVEN = "Backtest.commitBreakeven";
@@ -35347,7 +36581,7 @@ class BacktestUtils {
          * @param context - Execution context with strategyName, exchangeName, and frameName
          * @returns Effective entry price, or null if no active position
          */
-        this.getPositionAveragePrice = async (symbol, context) => {
+        this.getPositionEffectivePrice = async (symbol, context) => {
             bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_AVERAGE_PRICE, {
                 symbol,
                 context,
@@ -35363,7 +36597,7 @@ class BacktestUtils {
                 actions &&
                     actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_AVERAGE_PRICE));
             }
-            return await bt.strategyCoreService.getPositionAveragePrice(true, symbol, context);
+            return await bt.strategyCoreService.getPositionEffectivePrice(true, symbol, context);
         };
         /**
          * Returns the total number of base-asset units currently held in the position.
@@ -35581,6 +36815,230 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.getPositionEntries(true, symbol, context);
         };
+        /**
+         * Returns the original estimated duration for the current pending signal.
+         *
+         * Reflects `minuteEstimatedTime` as set in the signal DTO — the maximum
+         * number of minutes the position is expected to be active before `time_expired`.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Estimated duration in minutes, or null if no active position
+         */
+        this.getPositionEstimateMinutes = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES));
+            }
+            return await bt.strategyCoreService.getPositionEstimateMinutes(true, symbol, context);
+        };
+        /**
+         * Returns the remaining time before the position expires, clamped to zero.
+         *
+         * Computes elapsed minutes since `pendingAt` and subtracts from `minuteEstimatedTime`.
+         * Returns 0 once the estimate is exceeded (never negative).
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Remaining minutes (≥ 0), or null if no active position
+         */
+        this.getPositionCountdownMinutes = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES));
+            }
+            return await bt.strategyCoreService.getPositionCountdownMinutes(true, symbol, context);
+        };
+        /**
+         * Returns the best price reached in the profit direction during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns price or null if no active position
+         */
+        this.getPositionHighestProfitPrice = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE));
+            }
+            return await bt.strategyCoreService.getPositionHighestProfitPrice(true, symbol, context);
+        };
+        /**
+         * Returns the timestamp when the best profit price was recorded during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns timestamp in milliseconds or null if no active position
+         */
+        this.getPositionHighestProfitTimestamp = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP));
+            }
+            return await bt.strategyCoreService.getPositionHighestProfitTimestamp(true, symbol, context);
+        };
+        /**
+         * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns PnL percentage or null if no active position
+         */
+        this.getPositionHighestPnlPercentage = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE));
+            }
+            return await bt.strategyCoreService.getPositionHighestPnlPercentage(true, symbol, context);
+        };
+        /**
+         * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns PnL cost or null if no active position
+         */
+        this.getPositionHighestPnlCost = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST));
+            }
+            return await bt.strategyCoreService.getPositionHighestPnlCost(true, symbol, context);
+        };
+        /**
+         * Returns whether breakeven was mathematically reachable at the highest profit price.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns true if breakeven was reachable at peak, false otherwise, or null if no active position
+         */
+        this.getPositionHighestProfitBreakeven = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN));
+            }
+            return await bt.strategyCoreService.getPositionHighestProfitBreakeven(true, symbol, context);
+        };
+        /**
+         * Returns the number of minutes elapsed since the highest profit price was recorded.
+         *
+         * Measures how long the position has been pulling back from its peak profit level.
+         * Zero when called at the exact moment the peak was set.
+         * Grows continuously as price moves away from the peak without setting a new record.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns Drawdown duration in minutes, or null if no active position
+         */
+        this.getPositionDrawdownMinutes = async (symbol, context) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES));
+            }
+            return await bt.strategyCoreService.getPositionDrawdownMinutes(true, symbol, context);
+        };
         /**
          * Checks whether the current price falls within the tolerance zone of any existing DCA entry level.
          * Use this to prevent duplicate DCA entries at the same price area.
@@ -36142,7 +37600,7 @@ class BacktestUtils {
             if (!signal) {
                 return false;
             }
-            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(true, symbol, context);
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(true, symbol, context);
             if (effectivePriceOpen === null) {
                 return false;
             }
@@ -36227,7 +37685,7 @@ class BacktestUtils {
             if (!signal) {
                 return false;
             }
-            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(true, symbol, context);
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(true, symbol, context);
             if (effectivePriceOpen === null) {
                 return false;
             }
@@ -36280,7 +37738,7 @@ class BacktestUtils {
             if (!signal) {
                 return false;
             }
-            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(true, symbol, context);
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(true, symbol, context);
             if (effectivePriceOpen === null) {
                 return false;
             }
@@ -36334,7 +37792,7 @@ class BacktestUtils {
             if (!signal) {
                 return false;
             }
-            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(true, symbol, context);
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(true, symbol, context);
             if (effectivePriceOpen === null) {
                 return false;
             }
@@ -36396,7 +37854,7 @@ class BacktestUtils {
             if (!signal) {
                 return false;
             }
-            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(true, symbol, context);
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(true, symbol, context);
             if (effectivePriceOpen === null) {
                 return false;
             }
@@ -36684,7 +38142,7 @@ const LIVE_METHOD_NAME_GET_TOTAL_PERCENT_CLOSED = "LiveUtils.getTotalPercentClos
 const LIVE_METHOD_NAME_GET_TOTAL_COST_CLOSED = "LiveUtils.getTotalCostClosed";
 const LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL = "LiveUtils.getScheduledSignal";
 const LIVE_METHOD_NAME_GET_BREAKEVEN = "LiveUtils.getBreakeven";
-const LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE = "LiveUtils.getPositionAveragePrice";
+const LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE = "LiveUtils.getPositionEffectivePrice";
 const LIVE_METHOD_NAME_GET_POSITION_INVESTED_COUNT = "LiveUtils.getPositionInvestedCount";
 const LIVE_METHOD_NAME_GET_POSITION_INVESTED_COST = "LiveUtils.getPositionInvestedCost";
 const LIVE_METHOD_NAME_GET_POSITION_PNL_PERCENT = "LiveUtils.getPositionPnlPercent";
@@ -36692,6 +38150,14 @@ const LIVE_METHOD_NAME_GET_POSITION_PNL_COST = "LiveUtils.getPositionPnlCost";
 const LIVE_METHOD_NAME_GET_POSITION_LEVELS = "LiveUtils.getPositionLevels";
 const LIVE_METHOD_NAME_GET_POSITION_PARTIALS = "LiveUtils.getPositionPartials";
 const LIVE_METHOD_NAME_GET_POSITION_ENTRIES = "LiveUtils.getPositionEntries";
+const LIVE_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES = "LiveUtils.getPositionEstimateMinutes";
+const LIVE_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES = "LiveUtils.getPositionCountdownMinutes";
+const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE = "LiveUtils.getPositionHighestProfitPrice";
+const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP = "LiveUtils.getPositionHighestProfitTimestamp";
+const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE = "LiveUtils.getPositionHighestPnlPercentage";
+const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST = "LiveUtils.getPositionHighestPnlCost";
+const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN = "LiveUtils.getPositionHighestProfitBreakeven";
+const LIVE_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES = "LiveUtils.getPositionDrawdownMinutes";
 const LIVE_METHOD_NAME_GET_POSITION_ENTRY_OVERLAP = "LiveUtils.getPositionEntryOverlap";
 const LIVE_METHOD_NAME_GET_POSITION_PARTIAL_OVERLAP = "LiveUtils.getPositionPartialOverlap";
 const LIVE_METHOD_NAME_BREAKEVEN = "Live.commitBreakeven";
@@ -37295,7 +38761,7 @@ class LiveUtils {
          * @param context - Execution context with strategyName and exchangeName
          * @returns Effective entry price, or null if no active position
          */
-        this.getPositionAveragePrice = async (symbol, context) => {
+        this.getPositionEffectivePrice = async (symbol, context) => {
             bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE, {
                 symbol,
                 context,
@@ -37311,7 +38777,7 @@ class LiveUtils {
                 actions &&
                     actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_AVERAGE_PRICE));
             }
-            return await bt.strategyCoreService.getPositionAveragePrice(false, symbol, {
+            return await bt.strategyCoreService.getPositionEffectivePrice(false, symbol, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -37561,6 +39027,262 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns the original estimated duration for the current pending signal.
+         *
+         * Reflects `minuteEstimatedTime` as set in the signal DTO — the maximum
+         * number of minutes the position is expected to be active before `time_expired`.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Estimated duration in minutes, or null if no active position
+         */
+        this.getPositionEstimateMinutes = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_ESTIMATE_MINUTES));
+            }
+            return await bt.strategyCoreService.getPositionEstimateMinutes(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the remaining time before the position expires, clamped to zero.
+         *
+         * Computes elapsed minutes since `pendingAt` and subtracts from `minuteEstimatedTime`.
+         * Returns 0 once the estimate is exceeded (never negative).
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Remaining minutes (≥ 0), or null if no active position
+         */
+        this.getPositionCountdownMinutes = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_COUNTDOWN_MINUTES));
+            }
+            return await bt.strategyCoreService.getPositionCountdownMinutes(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the best price reached in the profit direction during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns price or null if no active position
+         */
+        this.getPositionHighestProfitPrice = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE));
+            }
+            return await bt.strategyCoreService.getPositionHighestProfitPrice(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the timestamp when the best profit price was recorded during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns timestamp in milliseconds or null if no active position
+         */
+        this.getPositionHighestProfitTimestamp = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP));
+            }
+            return await bt.strategyCoreService.getPositionHighestProfitTimestamp(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the PnL percentage at the moment the best profit price was recorded during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns PnL percentage or null if no active position
+         */
+        this.getPositionHighestPnlPercentage = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE));
+            }
+            return await bt.strategyCoreService.getPositionHighestPnlPercentage(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the PnL cost (in quote currency) at the moment the best profit price was recorded during this position's life.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns PnL cost or null if no active position
+         */
+        this.getPositionHighestPnlCost = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST));
+            }
+            return await bt.strategyCoreService.getPositionHighestPnlCost(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns whether breakeven was mathematically reachable at the highest profit price.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns true if breakeven was reachable at peak, false otherwise, or null if no active position
+         */
+        this.getPositionHighestProfitBreakeven = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN));
+            }
+            return await bt.strategyCoreService.getPositionHighestProfitBreakeven(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the number of minutes elapsed since the highest profit price was recorded.
+         *
+         * Measures how long the position has been pulling back from its peak profit level.
+         * Zero when called at the exact moment the peak was set.
+         * Grows continuously as price moves away from the peak without setting a new record.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns Drawdown duration in minutes, or null if no active position
+         */
+        this.getPositionDrawdownMinutes = async (symbol, context) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES, {
+                symbol,
+                context,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES));
+            }
+            return await bt.strategyCoreService.getPositionDrawdownMinutes(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
         /**
          * Checks whether the current price falls within the tolerance zone of any existing DCA entry level.
          * Use this to prevent duplicate DCA entries at the same price area.
@@ -38215,7 +39937,7 @@ class LiveUtils {
             if (!signal) {
                 return false;
             }
-            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(false, symbol, {
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(false, symbol, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -38315,7 +40037,7 @@ class LiveUtils {
             if (!signal) {
                 return false;
             }
-            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(false, symbol, {
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(false, symbol, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -38384,7 +40106,7 @@ class LiveUtils {
             if (!signal) {
                 return false;
             }
-            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(false, symbol, {
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(false, symbol, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -38454,7 +40176,7 @@ class LiveUtils {
             if (!signal) {
                 return false;
             }
-            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(false, symbol, {
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(false, symbol, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -38532,7 +40254,7 @@ class LiveUtils {
             if (!signal) {
                 return false;
             }
-            const effectivePriceOpen = await bt.strategyCoreService.getPositionAveragePrice(false, symbol, {
+            const effectivePriceOpen = await bt.strategyCoreService.getPositionEffectivePrice(false, symbol, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -41956,6 +43678,98 @@ class PartialUtils {
  */
 const Partial = new PartialUtils();
 
+const HIGHEST_PROFIT_METHOD_NAME_GET_DATA = "HighestProfitUtils.getData";
+const HIGHEST_PROFIT_METHOD_NAME_GET_REPORT = "HighestProfitUtils.getReport";
+const HIGHEST_PROFIT_METHOD_NAME_DUMP = "HighestProfitUtils.dump";
+/**
+ * Utility class for accessing highest profit reports and statistics.
+ *
+ * Provides static-like methods (via singleton instance) to retrieve data
+ * accumulated by HighestProfitMarkdownService from highestProfitSubject events.
+ *
+ * @example
+ * ```typescript
+ * import { HighestProfit } from "backtest-kit";
+ *
+ * const stats = await HighestProfit.getData("BTCUSDT", { strategyName, exchangeName, frameName });
+ * const report = await HighestProfit.getReport("BTCUSDT", { strategyName, exchangeName, frameName });
+ * await HighestProfit.dump("BTCUSDT", { strategyName, exchangeName, frameName });
+ * ```
+ */
+class HighestProfitUtils {
+    constructor() {
+        /**
+         * Retrieves statistical data from accumulated highest profit events.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context
+         * @param backtest - Whether to query backtest data
+         * @returns Promise resolving to HighestProfitStatisticsModel
+         */
+        this.getData = async (symbol, context, backtest = false) => {
+            bt.loggerService.info(HIGHEST_PROFIT_METHOD_NAME_GET_DATA, { symbol, strategyName: context.strategyName });
+            bt.strategyValidationService.validate(context.strategyName, HIGHEST_PROFIT_METHOD_NAME_GET_DATA);
+            bt.exchangeValidationService.validate(context.exchangeName, HIGHEST_PROFIT_METHOD_NAME_GET_DATA);
+            context.frameName && bt.frameValidationService.validate(context.frameName, HIGHEST_PROFIT_METHOD_NAME_GET_DATA);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, HIGHEST_PROFIT_METHOD_NAME_GET_DATA);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, HIGHEST_PROFIT_METHOD_NAME_GET_DATA));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, HIGHEST_PROFIT_METHOD_NAME_GET_DATA));
+            }
+            return await bt.highestProfitMarkdownService.getData(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+        };
+        /**
+         * Generates a markdown report with all highest profit events for a symbol-strategy pair.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context
+         * @param backtest - Whether to query backtest data
+         * @param columns - Optional column configuration
+         * @returns Promise resolving to markdown formatted report string
+         */
+        this.getReport = async (symbol, context, backtest = false, columns) => {
+            bt.loggerService.info(HIGHEST_PROFIT_METHOD_NAME_GET_REPORT, { symbol, strategyName: context.strategyName });
+            bt.strategyValidationService.validate(context.strategyName, HIGHEST_PROFIT_METHOD_NAME_GET_REPORT);
+            bt.exchangeValidationService.validate(context.exchangeName, HIGHEST_PROFIT_METHOD_NAME_GET_REPORT);
+            context.frameName && bt.frameValidationService.validate(context.frameName, HIGHEST_PROFIT_METHOD_NAME_GET_REPORT);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, HIGHEST_PROFIT_METHOD_NAME_GET_REPORT);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, HIGHEST_PROFIT_METHOD_NAME_GET_REPORT));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, HIGHEST_PROFIT_METHOD_NAME_GET_REPORT));
+            }
+            return await bt.highestProfitMarkdownService.getReport(symbol, context.strategyName, context.exchangeName, context.frameName, backtest, columns);
+        };
+        /**
+         * Generates and saves a markdown report to file.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Execution context
+         * @param backtest - Whether to query backtest data
+         * @param path - Output directory path (default: "./dump/highest_profit")
+         * @param columns - Optional column configuration
+         */
+        this.dump = async (symbol, context, backtest = false, path, columns) => {
+            bt.loggerService.info(HIGHEST_PROFIT_METHOD_NAME_DUMP, { symbol, strategyName: context.strategyName, path });
+            bt.strategyValidationService.validate(context.strategyName, HIGHEST_PROFIT_METHOD_NAME_DUMP);
+            bt.exchangeValidationService.validate(context.exchangeName, HIGHEST_PROFIT_METHOD_NAME_DUMP);
+            context.frameName && bt.frameValidationService.validate(context.frameName, HIGHEST_PROFIT_METHOD_NAME_DUMP);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, HIGHEST_PROFIT_METHOD_NAME_DUMP);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, HIGHEST_PROFIT_METHOD_NAME_DUMP));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, HIGHEST_PROFIT_METHOD_NAME_DUMP));
+            }
+            await bt.highestProfitMarkdownService.dump(symbol, context.strategyName, context.exchangeName, context.frameName, backtest, path, columns);
+        };
+    }
+}
+/**
+ * Global singleton instance of HighestProfitUtils.
+ */
+const HighestProfit = new HighestProfitUtils();
+
 /**
  * Utility class containing predefined trading constants for take-profit and stop-loss levels.
  *
@@ -46423,4 +48237,4 @@ const percentValue = (yesterdayValue, todayValue) => {
     return yesterdayValue / todayValue - 1;
 };
 
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Sync, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionAveragePrice, getPositionEntryOverlap, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, roundTicks, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, waitForCandle, warmCandles };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Exchange, ExecutionContextService, Heat, HighestProfit, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Sync, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpMessages, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, roundTicks, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, waitForCandle, warmCandles };