backtest-kit 5.5.3 → 5.6.0

package/build/index.cjs

@@ -127,6 +127,7 @@ const markdownServices$1 = {
     riskMarkdownService: Symbol('riskMarkdownService'),
     strategyMarkdownService: Symbol('strategyMarkdownService'),
     syncMarkdownService: Symbol('syncMarkdownService'),
+    highestProfitMarkdownService: Symbol('highestProfitMarkdownService'),
 };
 const reportServices$1 = {
     backtestReportService: Symbol('backtestReportService'),
@@ -140,6 +141,7 @@ const reportServices$1 = {
     riskReportService: Symbol('riskReportService'),
     strategyReportService: Symbol('strategyReportService'),
     syncReportService: Symbol('syncReportService'),
+    highestProfitReportService: Symbol('highestProfitReportService'),
 };
 const validationServices$1 = {
     exchangeValidationService: Symbol('exchangeValidationService'),
@@ -642,6 +644,12 @@ const strategyCommitSubject = new functoolsKit.Subject();
  * BacktestLogicPrivateService::*run
  */
 const backtestScheduleOpenSubject = new functoolsKit.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 functoolsKit.Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -653,6 +661,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     doneWalkerSubject: doneWalkerSubject,
     errorEmitter: errorEmitter,
     exitEmitter: exitEmitter,
+    highestProfitSubject: highestProfitSubject,
     partialLossSubject: partialLossSubject,
     partialProfitSubject: partialProfitSubject,
     performanceEmitter: performanceEmitter,
@@ -4271,6 +4280,7 @@ const GET_SIGNAL_FN = functoolsKit.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);
@@ -4295,6 +4305,7 @@ const GET_SIGNAL_FN = functoolsKit.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);
@@ -4315,6 +4326,7 @@ const GET_SIGNAL_FN = functoolsKit.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);
@@ -5017,6 +5029,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);
@@ -5653,7 +5666,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();
@@ -5674,6 +5687,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) {
@@ -5698,6 +5720,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) {
@@ -5745,7 +5776,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,
@@ -5755,6 +5786,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",
@@ -5767,6 +5815,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);
@@ -5806,6 +5855,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);
@@ -5955,7 +6005,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()
@@ -5985,6 +6036,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);
@@ -6186,6 +6238,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) {
@@ -6208,6 +6268,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) {
@@ -6584,8 +6652,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;
         }
@@ -6742,6 +6810,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.
      *
@@ -6917,6 +7149,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) {
@@ -7039,7 +7272,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.
@@ -9026,7 +9259,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);
@@ -9150,6 +9383,43 @@ const CREATE_COMMIT_FN = (self) => functoolsKit.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) => functoolsKit.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: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
  * Creates a callback function for emitting dispose events.
  *
@@ -9220,7 +9490,7 @@ class StrategyConnectionService {
          * @param backtest - Whether running in backtest mode
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$o(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
+        this.getStrategy = functoolsKit.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,
@@ -9248,6 +9518,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),
             });
         });
         /**
@@ -9321,14 +9592,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.
@@ -9678,6 +9949,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.
          *
@@ -9716,7 +10143,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;
             }
@@ -10889,7 +11316,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);
@@ -10988,7 +11415,7 @@ class RiskConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientRisk instance
          */
-        this.getRisk = functoolsKit.memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$n(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
+        this.getRisk = functoolsKit.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,
@@ -11056,7 +11483,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 {
@@ -12523,7 +12950,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);
@@ -12574,7 +13001,7 @@ class ActionConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientAction instance
          */
-        this.getAction = functoolsKit.memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$m(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
+        this.getAction = functoolsKit.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,
@@ -12784,7 +13211,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;
             }
@@ -12802,7 +13229,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;
 };
 /**
@@ -12826,7 +13253,7 @@ class ExchangeCoreService {
          * @param exchangeName - Name of the exchange to validate
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = functoolsKit.memoize(([exchangeName]) => CREATE_KEY_FN$l(exchangeName), async (exchangeName) => {
+        this.validate = functoolsKit.memoize(([exchangeName]) => CREATE_KEY_FN$m(exchangeName), async (exchangeName) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$2, {
                 exchangeName,
             });
@@ -13078,7 +13505,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);
@@ -13110,7 +13537,7 @@ class StrategyCoreService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$k(context), async (context) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$l(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$1, {
                 context,
             });
@@ -13174,13 +13601,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", {
@@ -13873,6 +14300,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);
+        };
     }
 }
 
@@ -13945,7 +14509,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);
@@ -13971,7 +14535,7 @@ class RiskGlobalService {
          * @param payload - Payload with riskName, exchangeName and frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$j(context), async (context) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$k(context), async (context) => {
             this.loggerService.log("riskGlobalService validate", {
                 context,
             });
@@ -14049,7 +14613,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);
@@ -14093,7 +14657,7 @@ class ActionCoreService {
          * @param context - Strategy execution context with strategyName, exchangeName and frameName
          * @returns Promise that resolves when all validations complete
          */
-        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$i(context), async (context) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$j(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE, {
                 context,
             });
@@ -17904,6 +18468,78 @@ 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: "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.
  *
@@ -18121,6 +18757,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 */
@@ -18161,6 +18799,7 @@ const WILDCARD_TARGET$1 = {
     schedule: true,
     walker: true,
     sync: true,
+    highest_profit: true,
 };
 /**
  * JSONL-based markdown adapter with append-only writes.
@@ -18388,7 +19027,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,
@@ -18401,6 +19040,7 @@ class MarkdownUtils {
                 schedule,
                 walker,
                 sync,
+                highest_profit,
             });
             const unList = [];
             if (bt$1) {
@@ -18436,6 +19076,9 @@ class MarkdownUtils {
             if (sync) {
                 unList.push(bt.syncMarkdownService.subscribe());
             }
+            if (highest_profit) {
+                unList.push(bt.highestProfitMarkdownService.subscribe());
+            }
             return functoolsKit.compose(...unList.map((un) => () => void un()));
         };
         /**
@@ -18475,7 +19118,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,
@@ -18488,6 +19131,7 @@ class MarkdownUtils {
                 schedule,
                 walker,
                 sync,
+                highest_profit,
             });
             if (bt$1) {
                 bt.backtestMarkdownService.unsubscribe();
@@ -18522,6 +19166,9 @@ class MarkdownUtils {
             if (sync) {
                 bt.syncMarkdownService.unsubscribe();
             }
+            if (highest_profit) {
+                bt.highestProfitMarkdownService.unsubscribe();
+            }
         };
     }
 }
@@ -18628,7 +19275,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);
@@ -18645,7 +19292,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);
@@ -18674,12 +19321,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;
@@ -18696,7 +19343,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();
         }
     }
@@ -18820,7 +19467,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,
@@ -18867,7 +19514,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 = functoolsKit.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 = functoolsKit.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.
@@ -19024,7 +19671,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 {
@@ -19086,7 +19733,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);
@@ -19103,7 +19750,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);
@@ -19132,12 +19779,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;
@@ -19169,7 +19816,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();
             }
         }
@@ -19199,7 +19846,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();
         }
     }
@@ -19243,7 +19890,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();
         }
     }
@@ -19280,7 +19927,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();
         }
     }
@@ -19308,7 +19955,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();
         }
     }
@@ -19351,7 +19998,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();
         }
     }
@@ -19380,7 +20027,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();
         }
     }
@@ -19519,7 +20166,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: "",
@@ -19569,7 +20216,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 = functoolsKit.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 = functoolsKit.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.
@@ -19787,7 +20434,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 {
@@ -19807,7 +20454,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);
@@ -19824,7 +20471,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);
@@ -19835,12 +20482,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;
@@ -19876,7 +20523,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();
         }
     }
@@ -19912,7 +20559,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();
         }
     }
@@ -19950,7 +20597,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();
         }
     }
@@ -20057,7 +20704,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,
@@ -20098,7 +20745,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 = functoolsKit.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 = functoolsKit.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.
@@ -20301,7 +20948,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 {
@@ -20321,7 +20968,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);
@@ -20338,7 +20985,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);
@@ -20358,7 +21005,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.
@@ -20380,7 +21027,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();
         }
     }
@@ -20522,7 +21169,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,
@@ -20569,7 +21216,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 = functoolsKit.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 = functoolsKit.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.
@@ -20736,7 +21383,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 {
@@ -20750,7 +21397,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`;
 };
 /**
@@ -20785,7 +21432,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) */
@@ -20973,7 +21620,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,
@@ -21009,7 +21656,7 @@ class WalkerMarkdownService {
          * Memoized function to get or create ReportStorage for a walker.
          * Each walker gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$5(walkerName));
+        this.getStorage = functoolsKit.memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$6(walkerName));
         /**
          * Subscribes to walker emitter to receive walker progress events.
          * Protected against multiple subscriptions.
@@ -21206,7 +21853,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);
@@ -21217,7 +21864,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);
@@ -21250,7 +21897,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.
@@ -21276,7 +21923,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();
         }
     }
@@ -21527,7 +22174,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,
@@ -21573,7 +22220,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 = functoolsKit.memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$d(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
+        this.getStorage = functoolsKit.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.
@@ -21768,7 +22415,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 {
@@ -22799,7 +23446,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.
  *
@@ -22921,7 +23568,7 @@ class PartialConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientPartial instance with logger and event emitters
          */
-        this.getPartial = functoolsKit.memoize(([signalId, backtest]) => CREATE_KEY_FN$c(signalId, backtest), (signalId, backtest) => {
+        this.getPartial = functoolsKit.memoize(([signalId, backtest]) => CREATE_KEY_FN$d(signalId, backtest), (signalId, backtest) => {
             return new ClientPartial({
                 signalId,
                 logger: this.loggerService,
@@ -23011,7 +23658,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);
         };
     }
@@ -23027,7 +23674,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);
@@ -23038,7 +23685,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);
@@ -23049,12 +23696,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;
@@ -23097,7 +23744,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();
         }
     }
@@ -23135,7 +23782,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();
         }
     }
@@ -23211,7 +23858,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,
@@ -23252,7 +23899,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 = functoolsKit.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 = functoolsKit.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.
@@ -23462,7 +24109,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 {
@@ -23478,7 +24125,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);
@@ -23552,7 +24199,7 @@ class PartialGlobalService {
          * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$a(context), (context, methodName) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$b(context), (context, methodName) => {
             this.loggerService.log("partialGlobalService validate", {
                 context,
                 methodName,
@@ -24007,7 +24654,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.
  *
@@ -24093,7 +24740,7 @@ class BreakevenConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientBreakeven instance with logger and event emitter
          */
-        this.getBreakeven = functoolsKit.memoize(([signalId, backtest]) => CREATE_KEY_FN$9(signalId, backtest), (signalId, backtest) => {
+        this.getBreakeven = functoolsKit.memoize(([signalId, backtest]) => CREATE_KEY_FN$a(signalId, backtest), (signalId, backtest) => {
             return new ClientBreakeven({
                 signalId,
                 logger: this.loggerService,
@@ -24154,7 +24801,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);
         };
     }
@@ -24170,7 +24817,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);
@@ -24181,7 +24828,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);
@@ -24192,12 +24839,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;
@@ -24238,7 +24885,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();
         }
     }
@@ -24306,7 +24953,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,
@@ -24347,7 +24994,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 = functoolsKit.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 = functoolsKit.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.
@@ -24536,7 +25183,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 {
@@ -24552,7 +25199,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);
@@ -24626,7 +25273,7 @@ class BreakevenGlobalService {
          * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$7(context), (context, methodName) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$8(context), (context, methodName) => {
             this.loggerService.log("breakevenGlobalService validate", {
                 context,
                 methodName,
@@ -24846,7 +25493,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);
@@ -24857,7 +25504,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);
@@ -24868,12 +25515,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;
@@ -24890,7 +25537,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();
         }
     }
@@ -24974,7 +25621,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,
@@ -25015,7 +25662,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 = functoolsKit.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 = functoolsKit.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.
@@ -25204,7 +25851,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 {
@@ -25502,6 +26149,7 @@ const WILDCARD_TARGET = {
     schedule: true,
     walker: true,
     sync: true,
+    highest_profit: true,
 };
 /**
  * Utility class for managing report services.
@@ -25539,7 +26187,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,
@@ -25587,6 +26235,9 @@ class ReportUtils {
             if (sync) {
                 unList.push(bt.syncReportService.subscribe());
             }
+            if (highest_profit) {
+                unList.push(bt.highestProfitReportService.subscribe());
+            }
             return functoolsKit.compose(...unList.map((un) => () => void un()));
         };
         /**
@@ -25625,7 +26276,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,
@@ -25672,6 +26323,9 @@ class ReportUtils {
             if (sync) {
                 bt.syncReportService.unsubscribe();
             }
+            if (highest_profit) {
+                bt.highestProfitReportService.unsubscribe();
+            }
         };
     }
 }
@@ -27879,6 +28533,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 = functoolsKit.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.
  *
@@ -27892,7 +28600,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);
@@ -27912,7 +28620,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);
@@ -27927,7 +28635,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.
  *
@@ -27940,7 +28648,7 @@ const MAX_EVENTS$1 = 250;
  *
  * @internal
  */
-let ReportStorage$1 = class ReportStorage {
+let ReportStorage$2 = class ReportStorage {
     /**
      * Creates a new ReportStorage instance.
      *
@@ -27966,7 +28674,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();
         }
     }
@@ -28071,7 +28779,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,
@@ -28140,7 +28848,7 @@ class StrategyMarkdownService {
          *
          * @internal
          */
-        this.getStorage = functoolsKit.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 = functoolsKit.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.
          *
@@ -28708,7 +29416,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 {
@@ -28816,7 +29524,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);
@@ -28827,7 +29535,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);
@@ -28838,12 +29546,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;
@@ -28853,7 +29561,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();
         }
     }
@@ -28914,7 +29622,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,
@@ -28925,7 +29633,7 @@ class ReportStorage {
             frameName: this.frameName,
         });
     }
-}
+};
 /**
  * Service for generating and saving signal sync markdown reports.
  *
@@ -28948,7 +29656,7 @@ class ReportStorage {
 class SyncMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = functoolsKit.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 = functoolsKit.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 = functoolsKit.singleshot(() => {
             this.loggerService.log("syncMarkdownService init");
             const unsubscribe = syncSubject.subscribe(this.tick);
@@ -29022,6 +29730,189 @@ 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,
+            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 = functoolsKit.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 = functoolsKit.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);
@@ -29371,6 +30262,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());
@@ -29384,6 +30276,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());
@@ -29466,6 +30359,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),
@@ -29479,6 +30373,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),
@@ -31250,7 +32145,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
@@ -31272,7 +32167,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
@@ -31297,7 +32192,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
  *
@@ -31324,7 +32219,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
  *
@@ -31363,7 +32258,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
@@ -32285,13 +33180,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";
 /**
@@ -32558,7 +33462,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;
     }
@@ -32638,7 +33542,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;
     }
@@ -32688,7 +33592,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;
     }
@@ -32739,7 +33643,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;
     }
@@ -32801,7 +33705,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;
     }
@@ -33097,26 +34001,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.
@@ -33471,6 +34375,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.
@@ -33648,6 +34830,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.
  *
@@ -34774,6 +35958,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(functoolsKit.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";
@@ -34787,7 +35998,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";
@@ -34795,6 +36006,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";
@@ -35367,7 +36586,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,
@@ -35383,7 +36602,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.
@@ -35601,6 +36820,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.
@@ -36162,7 +37605,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;
             }
@@ -36247,7 +37690,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;
             }
@@ -36300,7 +37743,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;
             }
@@ -36354,7 +37797,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;
             }
@@ -36416,7 +37859,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;
             }
@@ -36704,7 +38147,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";
@@ -36712,6 +38155,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";
@@ -37315,7 +38766,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,
@@ -37331,7 +38782,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: "",
@@ -37581,6 +39032,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.
@@ -38235,7 +39942,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: "",
@@ -38335,7 +40042,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: "",
@@ -38404,7 +40111,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: "",
@@ -38474,7 +40181,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: "",
@@ -38552,7 +40259,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: "",
@@ -41976,6 +43683,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.
  *
@@ -46453,6 +48252,7 @@ exports.Constant = Constant;
 exports.Exchange = Exchange;
 exports.ExecutionContextService = ExecutionContextService;
 exports.Heat = Heat;
+exports.HighestProfit = HighestProfit;
 exports.Live = Live;
 exports.Log = Log;
 exports.Markdown = Markdown;
@@ -46532,8 +48332,17 @@ exports.getMode = getMode;
 exports.getNextCandles = getNextCandles;
 exports.getOrderBook = getOrderBook;
 exports.getPendingSignal = getPendingSignal;
-exports.getPositionAveragePrice = getPositionAveragePrice;
+exports.getPositionCountdownMinutes = getPositionCountdownMinutes;
+exports.getPositionDrawdownMinutes = getPositionDrawdownMinutes;
+exports.getPositionEffectivePrice = getPositionEffectivePrice;
+exports.getPositionEntries = getPositionEntries;
 exports.getPositionEntryOverlap = getPositionEntryOverlap;
+exports.getPositionEstimateMinutes = getPositionEstimateMinutes;
+exports.getPositionHighestPnlCost = getPositionHighestPnlCost;
+exports.getPositionHighestPnlPercentage = getPositionHighestPnlPercentage;
+exports.getPositionHighestProfitBreakeven = getPositionHighestProfitBreakeven;
+exports.getPositionHighestProfitPrice = getPositionHighestProfitPrice;
+exports.getPositionHighestProfitTimestamp = getPositionHighestProfitTimestamp;
 exports.getPositionInvestedCost = getPositionInvestedCost;
 exports.getPositionInvestedCount = getPositionInvestedCount;
 exports.getPositionLevels = getPositionLevels;
@@ -46574,6 +48383,8 @@ exports.listenDoneWalker = listenDoneWalker;
 exports.listenDoneWalkerOnce = listenDoneWalkerOnce;
 exports.listenError = listenError;
 exports.listenExit = listenExit;
+exports.listenHighestProfit = listenHighestProfit;
+exports.listenHighestProfitOnce = listenHighestProfitOnce;
 exports.listenPartialLossAvailable = listenPartialLossAvailable;
 exports.listenPartialLossAvailableOnce = listenPartialLossAvailableOnce;
 exports.listenPartialProfitAvailable = listenPartialProfitAvailable;