backtest-kit 6.9.0 → 6.11.0

package/build/index.cjs

@@ -4147,53 +4147,6 @@ const toProfitLossDto = (signal, priceClose) => {
     };
 };
 
-/**
- * Converts markdown content to plain text with minimal formatting
- * @param content - Markdown string to convert
- * @returns Plain text representation
- */
-const toPlainString = (content) => {
-    if (!content) {
-        return "";
-    }
-    let text = content;
-    // Remove code blocks
-    text = text.replace(/```[\s\S]*?```/g, "");
-    text = text.replace(/`([^`]+)`/g, "$1");
-    // Remove images
-    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1");
-    // Convert links to text only (keep link text, remove URL)
-    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
-    // Remove headers (convert to plain text)
-    text = text.replace(/^#{1,6}\s+(.+)$/gm, "$1");
-    // Remove bold and italic markers
-    text = text.replace(/\*\*\*(.+?)\*\*\*/g, "$1");
-    text = text.replace(/\*\*(.+?)\*\*/g, "$1");
-    text = text.replace(/\*(.+?)\*/g, "$1");
-    text = text.replace(/___(.+?)___/g, "$1");
-    text = text.replace(/__(.+?)__/g, "$1");
-    text = text.replace(/_(.+?)_/g, "$1");
-    // Remove strikethrough
-    text = text.replace(/~~(.+?)~~/g, "$1");
-    // Convert lists to plain text with bullets
-    text = text.replace(/^\s*[-*+]\s+/gm, "• ");
-    text = text.replace(/^\s*\d+\.\s+/gm, "• ");
-    // Remove blockquotes
-    text = text.replace(/^\s*>\s+/gm, "");
-    // Remove horizontal rules
-    text = text.replace(/^(\*{3,}|-{3,}|_{3,})$/gm, "");
-    // Remove HTML tags
-    text = text.replace(/<[^>]+>/g, "");
-    // Remove excessive whitespace and normalize line breaks
-    text = text.replace(/\n[\s\n]*\n/g, "\n");
-    text = text.replace(/[ \t]+/g, " ");
-    // Remove all newline characters
-    text = text.replace(/\n/g, " ");
-    // Remove excessive spaces after newline removal
-    text = text.replace(/\s+/g, " ");
-    return text.trim();
-};
-
 /**
  * Returns the total closed state of a position using costBasisAtClose snapshots.
  *
@@ -4828,6 +4781,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, currentPrice, timestamp) => {
                 originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
+                note: publicSignal.note,
             });
             continue;
         }
@@ -4855,6 +4809,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, currentPrice, timestamp) => {
                 originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
+                note: publicSignal.note,
             });
             continue;
         }
@@ -4881,6 +4836,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, currentPrice, timestamp) => {
                 originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
+                note: publicSignal.note,
             });
             continue;
         }
@@ -4908,6 +4864,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, currentPrice, timestamp) => {
                 originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
+                note: publicSignal.note,
             });
             continue;
         }
@@ -4935,6 +4892,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, currentPrice, timestamp) => {
                 originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
+                note: publicSignal.note,
             });
             continue;
         }
@@ -4964,6 +4922,7 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, currentPrice, timestamp) => {
                 originalPriceOpen: publicSignal.originalPriceOpen,
                 scheduledAt: publicSignal.scheduledAt,
                 pendingAt: publicSignal.pendingAt,
+                note: publicSignal.note,
             });
             continue;
         }
@@ -5062,7 +5021,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
     const currentPrice = await self.params.exchange.getAveragePrice(self.params.execution.context.symbol);
     const timeoutMs = GLOBAL_CONFIG.CC_MAX_SIGNAL_GENERATION_SECONDS * 1000;
     const signal = await Promise.race([
-        self.params.getSignal(self.params.execution.context.symbol, self.params.execution.context.when),
+        self.params.getSignal(self.params.execution.context.symbol, self.params.execution.context.when, currentPrice),
         functoolsKit.sleep(timeoutMs).then(() => TIMEOUT_SYMBOL),
     ]);
     if (typeof signal === "symbol") {
@@ -5092,7 +5051,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
                 cost: signal.cost || GLOBAL_CONFIG.CC_POSITION_ENTRY_COST,
                 priceOpen: signal.priceOpen, // Используем priceOpen из сигнала
                 position: signal.position,
-                note: toPlainString(signal.note),
+                note: signal.note || "",
                 priceTakeProfit: signal.priceTakeProfit,
                 priceStopLoss: signal.priceStopLoss,
                 minuteEstimatedTime: signal.minuteEstimatedTime ?? GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES,
@@ -5118,7 +5077,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
             cost: signal.cost || GLOBAL_CONFIG.CC_POSITION_ENTRY_COST,
             priceOpen: signal.priceOpen,
             position: signal.position,
-            note: toPlainString(signal.note),
+            note: signal.note || "",
             priceTakeProfit: signal.priceTakeProfit,
             priceStopLoss: signal.priceStopLoss,
             minuteEstimatedTime: signal.minuteEstimatedTime ?? GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES,
@@ -5143,7 +5102,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
         cost: signal.cost || GLOBAL_CONFIG.CC_POSITION_ENTRY_COST,
         priceOpen: currentPrice,
         ...structuredClone(signal),
-        note: toPlainString(signal.note),
+        note: signal.note || "",
         minuteEstimatedTime: signal.minuteEstimatedTime ?? GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES,
         symbol: self.params.execution.context.symbol,
         exchangeName: self.params.method.context.exchangeName,
@@ -5890,6 +5849,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
             totalPartials: scheduled._partial?.length ?? 0,
             originalPriceOpen: scheduled.priceOpen,
             pnl: toProfitLossDto(scheduled, scheduled.priceOpen),
+            note: scheduled.note,
         });
         return null;
     }
@@ -6658,6 +6618,7 @@ const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePr
             totalPartials: scheduled._partial?.length ?? 0,
             originalPriceOpen: scheduled.priceOpen,
             pnl: toProfitLossDto(scheduled, averagePrice),
+            note: scheduled.note,
         });
     }
     await CALL_CANCEL_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, averagePrice, closeTimestamp, self.params.execution.context.backtest);
@@ -6736,6 +6697,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
             totalPartials: scheduled._partial?.length ?? 0,
             originalPriceOpen: scheduled.priceOpen,
             pnl: toProfitLossDto(scheduled, scheduled.priceOpen),
+            note: scheduled.note,
         });
         return false;
     }
@@ -6823,6 +6785,7 @@ const CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, closedSignal, aver
         totalPartials: closedSignal._partial?.length ?? 0,
         originalPriceOpen: closedSignal.priceOpen,
         pnl: toProfitLossDto(closedSignal, averagePrice),
+        note: closedSignal.note,
     });
     await CALL_CLOSE_CALLBACKS_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
     await CALL_PARTIAL_CLEAR_FN(self, self.params.execution.context.symbol, closedSignal, averagePrice, closeTimestamp, self.params.execution.context.backtest);
@@ -6923,6 +6886,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles, fra
                     totalPartials: activatedSignal._partial?.length ?? 0,
                     originalPriceOpen: activatedSignal.priceOpen,
                     pnl: toProfitLossDto(activatedSignal, averagePrice),
+                    note: activatedSignal.note,
                 });
                 return { outcome: "pending" };
             }
@@ -6954,6 +6918,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles, fra
                 pendingAt: publicSignalForCommit.pendingAt,
                 totalEntries: publicSignalForCommit.totalEntries,
                 totalPartials: publicSignalForCommit.totalPartials,
+                note: publicSignalForCommit.note,
             });
             await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, pendingSignal, pendingSignal.priceOpen, candle.timestamp, self.params.execution.context.backtest);
             await CALL_BACKTEST_SCHEDULE_OPEN_FN(self, self.params.execution.context.symbol, pendingSignal, candle.timestamp, self.params.execution.context.backtest);
@@ -7990,6 +7955,90 @@ class ClientStrategy {
         }
         return this._pendingSignal._fall.pnlCost;
     }
+    /**
+     * Returns the distance in PnL percentage between the current price and the highest profit peak.
+     *
+     * Measures how much PnL% the position has given back from its best point.
+     * Computed as: max(0, peakPnlPercentage - currentPnlPercentage).
+     * Zero when called at the exact moment the peak was set, or when current PnL >= peak PnL.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @returns Promise resolving to drawdown distance in PnL% (≥ 0) or null
+     */
+    async getPositionHighestProfitDistancePnlPercentage(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy getPositionHighestProfitDistancePnlPercentage", { symbol, currentPrice });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const currentPnl = toProfitLossDto(this._pendingSignal, currentPrice);
+        return Math.max(0, this._pendingSignal._peak.pnlPercentage - currentPnl.pnlPercentage);
+    }
+    /**
+     * Returns the distance in PnL cost between the current price and the highest profit peak.
+     *
+     * Measures how much PnL cost the position has given back from its best point.
+     * Computed as: max(0, peakPnlCost - currentPnlCost).
+     * Zero when called at the exact moment the peak was set, or when current PnL >= peak PnL.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @returns Promise resolving to drawdown distance in PnL cost (≥ 0) or null
+     */
+    async getPositionHighestProfitDistancePnlCost(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy getPositionHighestProfitDistancePnlCost", { symbol, currentPrice });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const currentPnl = toProfitLossDto(this._pendingSignal, currentPrice);
+        return Math.max(0, this._pendingSignal._peak.pnlCost - currentPnl.pnlCost);
+    }
+    /**
+     * Returns the distance in PnL percentage between the current price and the worst drawdown trough.
+     *
+     * Measures how much the position has recovered from its deepest loss point.
+     * Computed as: max(0, currentPnlPercentage - fallPnlPercentage).
+     * Zero when called at the exact moment the trough was set, or when current PnL <= trough PnL.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @returns Promise resolving to recovery distance in PnL% (≥ 0) or null
+     */
+    async getPositionHighestMaxDrawdownPnlPercentage(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy getPositionHighestMaxDrawdownPnlPercentage", { symbol, currentPrice });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const currentPnl = toProfitLossDto(this._pendingSignal, currentPrice);
+        return Math.max(0, currentPnl.pnlPercentage - this._pendingSignal._fall.pnlPercentage);
+    }
+    /**
+     * Returns the distance in PnL cost between the current price and the worst drawdown trough.
+     *
+     * Measures how much the position has recovered from its deepest loss point.
+     * Computed as: max(0, currentPnlCost - fallPnlCost).
+     * Zero when called at the exact moment the trough was set, or when current PnL <= trough PnL.
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @returns Promise resolving to recovery distance in PnL cost (≥ 0) or null
+     */
+    async getPositionHighestMaxDrawdownPnlCost(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy getPositionHighestMaxDrawdownPnlCost", { symbol, currentPrice });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        const currentPnl = toProfitLossDto(this._pendingSignal, currentPrice);
+        return Math.max(0, currentPnl.pnlCost - this._pendingSignal._fall.pnlCost);
+    }
     /**
      * Performs a single tick of strategy execution.
      *
@@ -8054,6 +8103,7 @@ class ClientStrategy {
                 totalPartials: cancelledSignal._partial?.length ?? 0,
                 originalPriceOpen: cancelledSignal.priceOpen,
                 pnl: toProfitLossDto(cancelledSignal, currentPrice),
+                note: cancelledSignal.note,
             });
             // Call onCancel callback
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -8107,6 +8157,7 @@ class ClientStrategy {
                 totalPartials: closedSignal._partial?.length ?? 0,
                 originalPriceOpen: closedSignal.priceOpen,
                 pnl: toProfitLossDto(closedSignal, currentPrice),
+                note: closedSignal.note,
             });
             // Call onClose callback
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -8188,6 +8239,7 @@ class ClientStrategy {
                     totalPartials: activatedSignal._partial?.length ?? 0,
                     originalPriceOpen: activatedSignal.priceOpen,
                     pnl: toProfitLossDto(activatedSignal, currentPrice),
+                    note: activatedSignal.note,
                 });
                 return await RETURN_IDLE_FN(this, currentPrice);
             }
@@ -8218,6 +8270,7 @@ class ClientStrategy {
                 pendingAt: publicSignalForCommit.pendingAt,
                 totalEntries: publicSignalForCommit.totalEntries,
                 totalPartials: publicSignalForCommit.totalPartials,
+                note: publicSignalForCommit.note,
             });
             // Call onOpen callback
             await CALL_OPEN_CALLBACKS_FN(this, this.params.execution.context.symbol, pendingSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -8353,6 +8406,7 @@ class ClientStrategy {
                 totalPartials: cancelledSignal._partial?.length ?? 0,
                 originalPriceOpen: cancelledSignal.priceOpen,
                 pnl: toProfitLossDto(cancelledSignal, currentPrice),
+                note: cancelledSignal.note,
             });
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             const cancelledResult = {
@@ -8407,6 +8461,7 @@ class ClientStrategy {
                 totalPartials: closedSignal._partial?.length ?? 0,
                 originalPriceOpen: closedSignal.priceOpen,
                 pnl: toProfitLossDto(closedSignal, currentPrice),
+                note: closedSignal.note,
             });
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
@@ -9956,6 +10011,8 @@ class MergeRisk {
     }
 }
 
+/** Default interval for strategies that do not specify one */
+const STRATEGY_DEFAULT_INTERVAL = "1m";
 /**
  * If syncSubject listener or any registered action throws, it means the signal was not properly synchronized
  * to the exchange (e.g. limit order failed to fill).
@@ -10341,7 +10398,7 @@ class StrategyConnectionService {
          * @returns Configured ClientStrategy instance
          */
         this.getStrategy = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$t(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
-            const { riskName = "", riskList = [], getSignal, interval, callbacks, } = this.strategySchemaService.get(strategyName);
+            const { riskName = "", riskList = [], getSignal, interval = STRATEGY_DEFAULT_INTERVAL, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
                 interval,
@@ -11097,6 +11154,90 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.getPositionMaxDrawdownPnlCost(symbol);
         };
+        /**
+         * Returns the distance in PnL percentage between the current price and the highest profit peak.
+         *
+         * Resolves current price via priceMetaService and delegates to
+         * ClientStrategy.getPositionHighestProfitDistancePnlPercentage().
+         * 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 distance in PnL% (≥ 0) or null
+         */
+        this.getPositionHighestProfitDistancePnlPercentage = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionHighestProfitDistancePnlPercentage", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const currentPrice = await this.priceMetaService.getCurrentPrice(symbol, context, backtest);
+            return await strategy.getPositionHighestProfitDistancePnlPercentage(symbol, currentPrice);
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the highest profit peak.
+         *
+         * Resolves current price via priceMetaService and delegates to
+         * ClientStrategy.getPositionHighestProfitDistancePnlCost().
+         * 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 distance in PnL cost (≥ 0) or null
+         */
+        this.getPositionHighestProfitDistancePnlCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionHighestProfitDistancePnlCost", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const currentPrice = await this.priceMetaService.getCurrentPrice(symbol, context, backtest);
+            return await strategy.getPositionHighestProfitDistancePnlCost(symbol, currentPrice);
+        };
+        /**
+         * Returns the distance in PnL percentage between the current price and the worst drawdown trough.
+         *
+         * Resolves current price via priceMetaService and delegates to
+         * ClientStrategy.getPositionHighestMaxDrawdownPnlPercentage().
+         * 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 recovery distance in PnL% (≥ 0) or null
+         */
+        this.getPositionHighestMaxDrawdownPnlPercentage = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionHighestMaxDrawdownPnlPercentage", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const currentPrice = await this.priceMetaService.getCurrentPrice(symbol, context, backtest);
+            return await strategy.getPositionHighestMaxDrawdownPnlPercentage(symbol, currentPrice);
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the worst drawdown trough.
+         *
+         * Resolves current price via priceMetaService and delegates to
+         * ClientStrategy.getPositionHighestMaxDrawdownPnlCost().
+         * 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 recovery distance in PnL cost (≥ 0) or null
+         */
+        this.getPositionHighestMaxDrawdownPnlCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getPositionHighestMaxDrawdownPnlCost", {
+                symbol,
+                context,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            const currentPrice = await this.priceMetaService.getCurrentPrice(symbol, context, backtest);
+            return await strategy.getPositionHighestMaxDrawdownPnlCost(symbol, currentPrice);
+        };
         /**
          * Disposes the ClientStrategy instance for the given context.
          *
@@ -15258,6 +15399,82 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.getPositionMaxDrawdownPnlCost(backtest, symbol, context);
         };
+        /**
+         * Returns the distance in PnL percentage between the current price and the highest profit peak.
+         *
+         * Delegates to StrategyConnectionService.getPositionHighestProfitDistancePnlPercentage().
+         * 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 distance in PnL% (≥ 0) or null
+         */
+        this.getPositionHighestProfitDistancePnlPercentage = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionHighestProfitDistancePnlPercentage", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionHighestProfitDistancePnlPercentage(backtest, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the highest profit peak.
+         *
+         * Delegates to StrategyConnectionService.getPositionHighestProfitDistancePnlCost().
+         * 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 distance in PnL cost (≥ 0) or null
+         */
+        this.getPositionHighestProfitDistancePnlCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionHighestProfitDistancePnlCost", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionHighestProfitDistancePnlCost(backtest, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL percentage between the current price and the worst drawdown trough.
+         *
+         * Delegates to StrategyConnectionService.getPositionHighestMaxDrawdownPnlPercentage().
+         * 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 recovery distance in PnL% (≥ 0) or null
+         */
+        this.getPositionHighestMaxDrawdownPnlPercentage = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionHighestMaxDrawdownPnlPercentage", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionHighestMaxDrawdownPnlPercentage(backtest, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the worst drawdown trough.
+         *
+         * Delegates to StrategyConnectionService.getPositionHighestMaxDrawdownPnlCost().
+         * 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 recovery distance in PnL cost (≥ 0) or null
+         */
+        this.getPositionHighestMaxDrawdownPnlCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getPositionHighestMaxDrawdownPnlCost", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getPositionHighestMaxDrawdownPnlCost(backtest, symbol, context);
+        };
     }
 }
 
@@ -15900,8 +16117,8 @@ class StrategySchemaService {
             if (strategySchema.actions?.some((value) => typeof value !== "string")) {
                 throw new Error(`strategy schema validation failed: invalid actions for strategyName=${strategySchema.strategyName} actions=[${strategySchema.actions}]`);
             }
-            if (typeof strategySchema.interval !== "string") {
-                throw new Error(`strategy schema validation failed: missing interval for strategyName=${strategySchema.strategyName}`);
+            if (strategySchema.interval && typeof strategySchema.interval !== "string") {
+                throw new Error(`strategy schema validation failed: invalid interval for strategyName=${strategySchema.strategyName}`);
             }
             if (typeof strategySchema.getSignal !== "function") {
                 throw new Error(`strategy schema validation failed: missing getSignal for strategyName=${strategySchema.strategyName}`);
@@ -17847,6 +18064,53 @@ class WalkerCommandService {
     }
 }
 
+/**
+ * Converts markdown content to plain text with minimal formatting
+ * @param content - Markdown string to convert
+ * @returns Plain text representation
+ */
+const toPlainString = (content) => {
+    if (!content) {
+        return "";
+    }
+    let text = content;
+    // Remove code blocks
+    text = text.replace(/```[\s\S]*?```/g, "");
+    text = text.replace(/`([^`]+)`/g, "$1");
+    // Remove images
+    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1");
+    // Convert links to text only (keep link text, remove URL)
+    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    // Remove headers (convert to plain text)
+    text = text.replace(/^#{1,6}\s+(.+)$/gm, "$1");
+    // Remove bold and italic markers
+    text = text.replace(/\*\*\*(.+?)\*\*\*/g, "$1");
+    text = text.replace(/\*\*(.+?)\*\*/g, "$1");
+    text = text.replace(/\*(.+?)\*/g, "$1");
+    text = text.replace(/___(.+?)___/g, "$1");
+    text = text.replace(/__(.+?)__/g, "$1");
+    text = text.replace(/_(.+?)_/g, "$1");
+    // Remove strikethrough
+    text = text.replace(/~~(.+?)~~/g, "$1");
+    // Convert lists to plain text with bullets
+    text = text.replace(/^\s*[-*+]\s+/gm, "• ");
+    text = text.replace(/^\s*\d+\.\s+/gm, "• ");
+    // Remove blockquotes
+    text = text.replace(/^\s*>\s+/gm, "");
+    // Remove horizontal rules
+    text = text.replace(/^(\*{3,}|-{3,}|_{3,})$/gm, "");
+    // Remove HTML tags
+    text = text.replace(/<[^>]+>/g, "");
+    // Remove excessive whitespace and normalize line breaks
+    text = text.replace(/\n[\s\n]*\n/g, "\n");
+    text = text.replace(/[ \t]+/g, " ");
+    // Remove all newline characters
+    text = text.replace(/\n/g, " ");
+    // Remove excessive spaces after newline removal
+    text = text.replace(/\s+/g, " ");
+    return text.trim();
+};
+
 /**
  * Column configuration for backtest markdown reports.
  *
@@ -18522,7 +18786,7 @@ const partial_columns = [
     {
         key: "note",
         label: "Note",
-        format: (data) => data.note || "",
+        format: (data) => toPlainString(data.note ?? "N/A"),
         isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
     },
     {
@@ -18682,7 +18946,7 @@ const breakeven_columns = [
     {
         key: "note",
         label: "Note",
-        format: (data) => data.note || "",
+        format: (data) => toPlainString(data.note ?? "N/A"),
         isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
     },
     {
@@ -34913,6 +35177,10 @@ const GET_POSITION_MAX_DRAWDOWN_PRICE_METHOD_NAME = "strategy.getPositionMaxDraw
 const GET_POSITION_MAX_DRAWDOWN_TIMESTAMP_METHOD_NAME = "strategy.getPositionMaxDrawdownTimestamp";
 const GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE_METHOD_NAME = "strategy.getPositionMaxDrawdownPnlPercentage";
 const GET_POSITION_MAX_DRAWDOWN_PNL_COST_METHOD_NAME = "strategy.getPositionMaxDrawdownPnlCost";
+const GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE_METHOD_NAME = "strategy.getPositionHighestProfitDistancePnlPercentage";
+const GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST_METHOD_NAME = "strategy.getPositionHighestProfitDistancePnlCost";
+const GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE_METHOD_NAME = "strategy.getPositionHighestMaxDrawdownPnlPercentage";
+const GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST_METHOD_NAME = "strategy.getPositionHighestMaxDrawdownPnlCost";
 const GET_POSITION_ENTRY_OVERLAP_METHOD_NAME = "strategy.getPositionEntryOverlap";
 const GET_POSITION_PARTIAL_OVERLAP_METHOD_NAME = "strategy.getPositionPartialOverlap";
 const HAS_NO_PENDING_SIGNAL_METHOD_NAME = "strategy.hasNoPendingSignal";
@@ -36547,6 +36815,122 @@ async function getPositionMaxDrawdownPnlCost(symbol) {
     const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
     return await backtest.strategyCoreService.getPositionMaxDrawdownPnlCost(isBacktest, symbol, { exchangeName, frameName, strategyName });
 }
+/**
+ * Returns the distance in PnL percentage between the current price and the highest profit peak.
+ *
+ * Computed as: max(0, peakPnlPercentage - currentPnlPercentage).
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to drawdown distance in PnL% (≥ 0) or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestProfitDistancePnlPercentage } from "backtest-kit";
+ *
+ * const dist = await getPositionHighestProfitDistancePnlPercentage("BTCUSDT");
+ * // e.g. 1.5 (gave back 1.5% from peak)
+ * ```
+ */
+async function getPositionHighestProfitDistancePnlPercentage(symbol) {
+    backtest.loggerService.info(GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitDistancePnlPercentage requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitDistancePnlPercentage requires a method context");
+    }
+    const { backtest: isBacktest } = backtest.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await backtest.strategyCoreService.getPositionHighestProfitDistancePnlPercentage(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the distance in PnL cost between the current price and the highest profit peak.
+ *
+ * Computed as: max(0, peakPnlCost - currentPnlCost).
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to drawdown distance in PnL cost (≥ 0) or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestProfitDistancePnlCost } from "backtest-kit";
+ *
+ * const dist = await getPositionHighestProfitDistancePnlCost("BTCUSDT");
+ * // e.g. 3.2 (gave back $3.2 from peak)
+ * ```
+ */
+async function getPositionHighestProfitDistancePnlCost(symbol) {
+    backtest.loggerService.info(GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitDistancePnlCost requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionHighestProfitDistancePnlCost requires a method context");
+    }
+    const { backtest: isBacktest } = backtest.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await backtest.strategyCoreService.getPositionHighestProfitDistancePnlCost(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the distance in PnL percentage between the current price and the worst drawdown trough.
+ *
+ * Computed as: max(0, currentPnlPercentage - fallPnlPercentage).
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to recovery distance in PnL% (≥ 0) or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestMaxDrawdownPnlPercentage } from "backtest-kit";
+ *
+ * const dist = await getPositionHighestMaxDrawdownPnlPercentage("BTCUSDT");
+ * // e.g. 2.1 (recovered 2.1% from trough)
+ * ```
+ */
+async function getPositionHighestMaxDrawdownPnlPercentage(symbol) {
+    backtest.loggerService.info(GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionHighestMaxDrawdownPnlPercentage requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionHighestMaxDrawdownPnlPercentage requires a method context");
+    }
+    const { backtest: isBacktest } = backtest.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlPercentage(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the distance in PnL cost between the current price and the worst drawdown trough.
+ *
+ * Computed as: max(0, currentPnlCost - fallPnlCost).
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to recovery distance in PnL cost (≥ 0) or null
+ *
+ * @example
+ * ```typescript
+ * import { getPositionHighestMaxDrawdownPnlCost } from "backtest-kit";
+ *
+ * const dist = await getPositionHighestMaxDrawdownPnlCost("BTCUSDT");
+ * // e.g. 4.8 (recovered $4.8 from trough)
+ * ```
+ */
+async function getPositionHighestMaxDrawdownPnlCost(symbol) {
+    backtest.loggerService.info(GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getPositionHighestMaxDrawdownPnlCost requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getPositionHighestMaxDrawdownPnlCost requires a method context");
+    }
+    const { backtest: isBacktest } = backtest.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlCost(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.
@@ -38216,6 +38600,10 @@ const BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE = "BacktestUtils.getP
 const BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP = "BacktestUtils.getPositionMaxDrawdownTimestamp";
 const BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE = "BacktestUtils.getPositionMaxDrawdownPnlPercentage";
 const BACKTEST_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST = "BacktestUtils.getPositionMaxDrawdownPnlCost";
+const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE = "BacktestUtils.getPositionHighestProfitDistancePnlPercentage";
+const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST = "BacktestUtils.getPositionHighestProfitDistancePnlCost";
+const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE = "BacktestUtils.getPositionHighestMaxDrawdownPnlPercentage";
+const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST = "BacktestUtils.getPositionHighestMaxDrawdownPnlCost";
 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";
@@ -39485,6 +39873,118 @@ class BacktestUtils {
             }
             return await backtest.strategyCoreService.getPositionMaxDrawdownPnlCost(true, symbol, context);
         };
+        /**
+         * Returns the distance in PnL percentage between the current price and the highest profit peak.
+         *
+         * Computed as: max(0, peakPnlPercentage - currentPnlPercentage).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns drawdown distance in PnL% (≥ 0) or null if no active position
+         */
+        this.getPositionHighestProfitDistancePnlPercentage = async (symbol, context) => {
+            backtest.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getPositionHighestProfitDistancePnlPercentage(true, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the highest profit peak.
+         *
+         * Computed as: max(0, peakPnlCost - currentPnlCost).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns drawdown distance in PnL cost (≥ 0) or null if no active position
+         */
+        this.getPositionHighestProfitDistancePnlCost = async (symbol, context) => {
+            backtest.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getPositionHighestProfitDistancePnlCost(true, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL percentage between the current price and the worst drawdown trough.
+         *
+         * Computed as: max(0, currentPnlPercentage - fallPnlPercentage).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns recovery distance in PnL% (≥ 0) or null if no active position
+         */
+        this.getPositionHighestMaxDrawdownPnlPercentage = async (symbol, context) => {
+            backtest.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlPercentage(true, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the worst drawdown trough.
+         *
+         * Computed as: max(0, currentPnlCost - fallPnlCost).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns recovery distance in PnL cost (≥ 0) or null if no active position
+         */
+        this.getPositionHighestMaxDrawdownPnlCost = async (symbol, context) => {
+            backtest.loggerService.info(BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlCost(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.
@@ -40610,6 +41110,10 @@ const LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE = "LiveUtils.getPositionM
 const LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP = "LiveUtils.getPositionMaxDrawdownTimestamp";
 const LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE = "LiveUtils.getPositionMaxDrawdownPnlPercentage";
 const LIVE_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST = "LiveUtils.getPositionMaxDrawdownPnlCost";
+const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE = "LiveUtils.getPositionHighestProfitDistancePnlPercentage";
+const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST = "LiveUtils.getPositionHighestProfitDistancePnlCost";
+const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE = "LiveUtils.getPositionHighestMaxDrawdownPnlPercentage";
+const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST = "LiveUtils.getPositionHighestMaxDrawdownPnlCost";
 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";
@@ -42006,6 +42510,134 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns the distance in PnL percentage between the current price and the highest profit peak.
+         *
+         * Computed as: max(0, peakPnlPercentage - currentPnlPercentage).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns drawdown distance in PnL% (≥ 0) or null if no active position
+         */
+        this.getPositionHighestProfitDistancePnlPercentage = async (symbol, context) => {
+            backtest.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getPositionHighestProfitDistancePnlPercentage(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the highest profit peak.
+         *
+         * Computed as: max(0, peakPnlCost - currentPnlCost).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns drawdown distance in PnL cost (≥ 0) or null if no active position
+         */
+        this.getPositionHighestProfitDistancePnlCost = async (symbol, context) => {
+            backtest.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getPositionHighestProfitDistancePnlCost(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the distance in PnL percentage between the current price and the worst drawdown trough.
+         *
+         * Computed as: max(0, currentPnlPercentage - fallPnlPercentage).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns recovery distance in PnL% (≥ 0) or null if no active position
+         */
+        this.getPositionHighestMaxDrawdownPnlPercentage = async (symbol, context) => {
+            backtest.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlPercentage(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the worst drawdown trough.
+         *
+         * Computed as: max(0, currentPnlCost - fallPnlCost).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns recovery distance in PnL cost (≥ 0) or null if no active position
+         */
+        this.getPositionHighestMaxDrawdownPnlCost = async (symbol, context) => {
+            backtest.loggerService.info(LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlCost(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.
@@ -51053,6 +51685,7 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
             pnlEntries: data.signal.pnl.pnlEntries,
             scheduledAt: data.signal.scheduledAt,
             currentPrice: data.currentPrice,
+            note: data.signal.note,
             createdAt: data.createdAt,
         };
     }
@@ -51082,6 +51715,7 @@ const CREATE_SIGNAL_NOTIFICATION_FN = (data) => {
             duration: durationMin,
             scheduledAt: data.signal.scheduledAt,
             pendingAt: data.signal.pendingAt,
+            note: data.signal.note,
             createdAt: data.createdAt,
         };
     }
@@ -51118,6 +51752,7 @@ const CREATE_PARTIAL_PROFIT_NOTIFICATION_FN = (data) => ({
     pnlPriceClose: data.data.pnl.priceClose,
     pnlCost: data.data.pnl.pnlCost,
     pnlEntries: data.data.pnl.pnlEntries,
+    note: data.data.note,
     scheduledAt: data.data.scheduledAt,
     pendingAt: data.data.pendingAt,
     createdAt: data.timestamp,
@@ -51153,6 +51788,7 @@ const CREATE_PARTIAL_LOSS_NOTIFICATION_FN = (data) => ({
     pnlPriceClose: data.data.pnl.priceClose,
     pnlCost: data.data.pnl.pnlCost,
     pnlEntries: data.data.pnl.pnlEntries,
+    note: data.data.note,
     scheduledAt: data.data.scheduledAt,
     pendingAt: data.data.pendingAt,
     createdAt: data.timestamp,
@@ -51187,6 +51823,7 @@ const CREATE_BREAKEVEN_NOTIFICATION_FN = (data) => ({
     pnlPriceClose: data.data.pnl.priceClose,
     pnlCost: data.data.pnl.pnlCost,
     pnlEntries: data.data.pnl.pnlEntries,
+    note: data.data.note,
     scheduledAt: data.data.scheduledAt,
     pendingAt: data.data.pendingAt,
     createdAt: data.timestamp,
@@ -51228,6 +51865,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlEntries: data.pnl.pnlEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -51260,6 +51898,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlEntries: data.pnl.pnlEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -51291,6 +51930,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlEntries: data.pnl.pnlEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -51323,6 +51963,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlEntries: data.pnl.pnlEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -51355,6 +51996,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlEntries: data.pnl.pnlEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -51387,6 +52029,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlEntries: data.pnl.pnlEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -51420,6 +52063,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlEntries: data.pnl.pnlEntries,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -51443,6 +52087,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlPriceClose: data.pnl.priceClose,
             pnlCost: data.pnl.pnlCost,
             pnlEntries: data.pnl.pnlEntries,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -51466,6 +52111,7 @@ const CREATE_STRATEGY_COMMIT_NOTIFICATION_FN = (data) => {
             pnlPriceClose: data.pnl.priceClose,
             pnlCost: data.pnl.pnlCost,
             pnlEntries: data.pnl.pnlEntries,
+            note: data.note,
             createdAt: data.timestamp,
         };
     }
@@ -51507,6 +52153,7 @@ const CREATE_SIGNAL_SYNC_NOTIFICATION_FN = (data) => {
             totalPartials: data.totalPartials,
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
+            note: data.signal.note,
             createdAt: data.timestamp,
         };
     }
@@ -51539,6 +52186,7 @@ const CREATE_SIGNAL_SYNC_NOTIFICATION_FN = (data) => {
             scheduledAt: data.scheduledAt,
             pendingAt: data.pendingAt,
             closeReason: data.closeReason,
+            note: data.signal.note,
             createdAt: data.timestamp,
         };
     }
@@ -53038,6 +53686,7 @@ const CACHE_METHOD_NAME_FILE = "CacheUtils.file";
 const CACHE_METHOD_NAME_FILE_CLEAR = "CacheUtils.file.clear";
 const CACHE_METHOD_NAME_DISPOSE = "CacheUtils.dispose";
 const CACHE_METHOD_NAME_CLEAR = "CacheUtils.clear";
+const CACHE_METHOD_NAME_RESET_COUNTER = "CacheUtils.resetCounter";
 const CACHE_FILE_INSTANCE_METHOD_NAME_RUN = "CacheFileInstance.run";
 const MS_PER_MINUTE$1 = 60000;
 const INTERVAL_MINUTES$1 = {
@@ -53289,7 +53938,7 @@ class CacheFileInstance {
     /**
      * Clears the index counter.
      */
-    static clearCounter() {
+    static resetCounter() {
         CacheFileInstance._indexCounter = 0;
     }
     /**
@@ -53544,11 +54193,17 @@ class CacheUtils {
          */
         this.clear = () => {
             backtest.loggerService.info(CACHE_METHOD_NAME_CLEAR);
-            {
-                this._getFnInstance.clear();
-                this._getFileInstance.clear();
-            }
-            CacheFileInstance.clearCounter();
+            this._getFnInstance.clear();
+            this._getFileInstance.clear();
+        };
+        /**
+         * Resets the CacheFileInstance index counter to zero.
+         * This is useful when process.cwd() changes between strategy iterations to ensure
+         * that new CacheFileInstance objects start with index 0 and do not collide with old instances.
+         */
+        this.resetCounter = () => {
+            backtest.loggerService.info(CACHE_METHOD_NAME_RESET_COUNTER);
+            CacheFileInstance.resetCounter();
         };
     }
 }
@@ -53572,10 +54227,12 @@ const INTERVAL_METHOD_NAME_RUN = "IntervalFnInstance.run";
 const INTERVAL_FILE_INSTANCE_METHOD_NAME_RUN = "IntervalFileInstance.run";
 const INTERVAL_METHOD_NAME_FN = "IntervalUtils.fn";
 const INTERVAL_METHOD_NAME_FN_CLEAR = "IntervalUtils.fn.clear";
+const INTERVAL_METHOD_NAME_FN_GC = "IntervalUtils.fn.gc";
 const INTERVAL_METHOD_NAME_FILE = "IntervalUtils.file";
 const INTERVAL_METHOD_NAME_FILE_CLEAR = "IntervalUtils.file.clear";
 const INTERVAL_METHOD_NAME_DISPOSE = "IntervalUtils.dispose";
 const INTERVAL_METHOD_NAME_CLEAR = "IntervalUtils.clear";
+const INTERVAL_METHOD_NAME_RESET_COUNTER = "IntervalUtils.resetCounter";
 const MS_PER_MINUTE = 60000;
 const INTERVAL_MINUTES = {
     "1m": 1,
@@ -53642,45 +54299,51 @@ const CREATE_KEY_FN = (strategyName, exchangeName, frameName, isBacktest) => {
  *
  * State is kept in memory; use `IntervalFileInstance` for persistence across restarts.
  *
+ * @template F - Concrete function type
+ *
  * @example
  * ```typescript
  * const instance = new IntervalFnInstance(mySignalFn, "1h");
- * await instance.run("BTCUSDT"); // → ISignalIntervalDto | null  (fn called)
- * await instance.run("BTCUSDT"); // → null                       (skipped, same interval)
+ * await instance.run("BTCUSDT"); // → T | null  (fn called)
+ * await instance.run("BTCUSDT"); // → null      (skipped, same interval)
  * // After 1 hour passes:
- * await instance.run("BTCUSDT"); // → ISignalIntervalDto | null  (fn called again)
+ * await instance.run("BTCUSDT"); // → T | null  (fn called again)
  * ```
  */
 class IntervalFnInstance {
     /**
      * Creates a new IntervalFnInstance.
      *
-     * @param fn - Signal function to fire once per interval
+     * @param fn - Function to fire once per interval
      * @param interval - Candle interval that controls the firing boundary
+     * @param key - Optional key generator for argument-based state separation.
+     *              Default: `([symbol]) => symbol`
      */
-    constructor(fn, interval) {
+    constructor(fn, interval, key = ([symbol]) => symbol) {
         this.fn = fn;
         this.interval = interval;
-        /** Stores the last aligned timestamp per context+symbol key. */
+        this.key = key;
+        /** Stores the last aligned timestamp per context+symbol+args key. */
         this._stateMap = new Map();
         /**
          * Execute the signal function with once-per-interval enforcement.
          *
          * Algorithm:
          * 1. Align the current execution context `when` to the interval boundary.
-         * 2. If the stored aligned timestamp for this context+symbol equals the current one → return `null`.
-         * 3. Otherwise call `fn`. If it returns a non-null signal, record the aligned timestamp and return
+         * 2. Build state key from context + key generator result.
+         * 3. If the stored aligned timestamp for this key equals the current one → return `null`.
+         * 4. Otherwise call `fn`. If it returns a non-null signal, record the aligned timestamp and return
          *    the signal. If it returns `null`, leave state unchanged so the next call retries.
          *
          * Requires active method context and execution context.
          *
-         * @param symbol - Trading pair symbol (e.g. "BTCUSDT")
-         * @returns The signal returned by `fn` on the first non-null fire, `null` on all subsequent calls
+         * @param args - Arguments forwarded to the wrapped function
+         * @returns The value returned by `fn` on the first non-null fire, `null` on all subsequent calls
          *   within the same interval or when `fn` itself returned `null`
          * @throws Error if method context, execution context, or interval is missing
          */
-        this.run = async (symbol) => {
-            backtest.loggerService.debug(INTERVAL_METHOD_NAME_RUN, { symbol });
+        this.run = async (...args) => {
+            backtest.loggerService.debug(INTERVAL_METHOD_NAME_RUN, { args });
             const step = INTERVAL_MINUTES[this.interval];
             {
                 if (!MethodContextService.hasContext()) {
@@ -53694,15 +54357,16 @@ class IntervalFnInstance {
                 }
             }
             const contextKey = CREATE_KEY_FN(backtest.methodContextService.context.strategyName, backtest.methodContextService.context.exchangeName, backtest.methodContextService.context.frameName, backtest.executionContextService.context.backtest);
-            const key = `${contextKey}:${symbol}`;
             const currentWhen = backtest.executionContextService.context.when;
             const currentAligned = align(currentWhen.getTime(), this.interval);
-            if (this._stateMap.get(key) === currentAligned) {
+            const argKey = this.key(args);
+            const stateKey = `${contextKey}:${argKey}`;
+            if (this._stateMap.get(stateKey) === currentAligned) {
                 return null;
             }
-            const result = await this.fn(symbol, currentWhen);
+            const result = await this.fn.apply(null, args);
             if (result !== null) {
-                this._stateMap.set(key, currentAligned);
+                this._stateMap.set(stateKey, currentAligned);
             }
             return result;
         };
@@ -53723,6 +54387,28 @@ class IntervalFnInstance {
                 }
             }
         };
+        /**
+         * Garbage collect expired state entries.
+         *
+         * Removes all entries whose aligned timestamp differs from the current interval boundary.
+         * Call this periodically to free memory from stale state entries.
+         *
+         * Requires active execution context to get current time.
+         *
+         * @returns Number of entries removed
+         */
+        this.gc = () => {
+            const currentWhen = backtest.executionContextService.context.when;
+            const currentAligned = align(currentWhen.getTime(), this.interval);
+            let removed = 0;
+            for (const [key, storedAligned] of this._stateMap.entries()) {
+                if (storedAligned !== currentAligned) {
+                    this._stateMap.delete(key);
+                    removed++;
+                }
+            }
+            return removed;
+        };
     }
 }
 /**
@@ -53736,13 +54422,13 @@ class IntervalFnInstance {
  *
  * Fired state survives process restarts — unlike `IntervalFnInstance` which is in-memory only.
  *
- * @template T - Async function type: `(symbol: string, ...args) => Promise<ISignalIntervalDto | null>`
+ * @template F - Concrete async function type
  *
  * @example
  * ```typescript
  * const instance = new IntervalFileInstance(fetchSignal, "1h", "mySignal");
- * await instance.run("BTCUSDT"); // → ISignalIntervalDto | null  (fn called, result written to disk)
- * await instance.run("BTCUSDT"); // → null                       (record exists, already fired)
+ * await instance.run("BTCUSDT"); // → R | null  (fn called, result written to disk)
+ * await instance.run("BTCUSDT"); // → null      (record exists, already fired)
  * ```
  */
 class IntervalFileInstance {
@@ -53757,7 +54443,7 @@ class IntervalFileInstance {
      * Resets the index counter to zero.
      * Call this when clearing all instances (e.g. on `IntervalUtils.clear()`).
      */
-    static clearCounter() {
+    static resetCounter() {
         IntervalFileInstance._indexCounter = 0;
     }
     /**
@@ -53766,26 +54452,30 @@ class IntervalFileInstance {
      * @param fn - Async signal function to fire once per interval
      * @param interval - Candle interval that controls the firing boundary
      * @param name - Human-readable bucket name used as the directory prefix
+     * @param key - Dynamic key generator; receives `[symbol, alignMs, ...rest]`.
+     *              Default: `([symbol, alignMs]) => \`${symbol}_${alignMs}\``
      */
-    constructor(fn, interval, name) {
+    constructor(fn, interval, name, key = ([symbol, alignMs]) => `${symbol}_${alignMs}`) {
         this.fn = fn;
         this.interval = interval;
         this.name = name;
+        this.key = key;
         /**
-         * Execute the async signal function with persistent once-per-interval enforcement.
+         * Execute the async function with persistent once-per-interval enforcement.
          *
          * Algorithm:
          * 1. Build bucket = `${name}_${interval}_${index}` — fixed per instance, used as directory name.
-         * 2. Align execution context `when` to interval boundary → `alignedTs`.
-         * 3. Build entity key = `${symbol}_${alignedTs}`.
+         * 2. Align execution context `when` to interval boundary → `alignedMs`.
+         * 3. Build entity key from the key generator (receives `[symbol, alignedMs, ...rest]`).
          * 4. Try to read from `PersistIntervalAdapter` using (bucket, entityKey).
          * 5. On hit — return `null` (interval already fired).
          * 6. On miss — call `fn`. If non-null, write to disk and return result. If null, skip write and return null.
          *
          * Requires active method context and execution context.
          *
-         * @param args - Arguments forwarded to the wrapped function (first must be `symbol: string`)
-         * @returns The signal on the first non-null fire, `null` if already fired this interval
+         * @param symbol - Trading pair symbol (e.g. "BTCUSDT")
+         * @param args - Additional arguments forwarded to the wrapped function
+         * @returns The value on the first non-null fire, `null` if already fired this interval
          *   or if `fn` itself returned `null`
          * @throws Error if method context, execution context, or interval is missing
          */
@@ -53803,11 +54493,11 @@ class IntervalFileInstance {
                     throw new Error(`IntervalFileInstance unknown interval=${this.interval}`);
                 }
             }
-            const [symbol] = args;
+            const [symbol, ...rest] = args;
             const { when } = backtest.executionContextService.context;
-            const alignedTs = align(when.getTime(), this.interval);
+            const alignedMs = align(when.getTime(), this.interval);
             const bucket = `${this.name}_${this.interval}_${this.index}`;
-            const entityKey = `${symbol}_${alignedTs}`;
+            const entityKey = this.key([symbol, alignedMs, ...rest]);
             const cached = await PersistIntervalAdapter.readIntervalData(bucket, entityKey);
             if (cached !== null) {
                 return null;
@@ -53843,8 +54533,8 @@ IntervalFileInstance._indexCounter = 0;
  * import { Interval } from "./classes/Interval";
  *
  * const fireOncePerHour = Interval.fn(mySignalFn, { interval: "1h" });
- * await fireOncePerHour("BTCUSDT", when); // fn called — returns its result
- * await fireOncePerHour("BTCUSDT", when); // returns null (same interval)
+ * await fireOncePerHour("BTCUSDT"); // fn called — returns its result
+ * await fireOncePerHour("BTCUSDT"); // returns null (same interval)
  * ```
  */
 class IntervalUtils {
@@ -53853,12 +54543,12 @@ class IntervalUtils {
          * Memoized factory to get or create an `IntervalFnInstance` for a function.
          * Each function reference gets its own isolated instance.
          */
-        this._getInstance = functoolsKit.memoize(([run]) => run, (run, interval) => new IntervalFnInstance(run, interval));
+        this._getInstance = functoolsKit.memoize(([run]) => run, (run, interval, key) => new IntervalFnInstance(run, interval, key));
         /**
          * Memoized factory to get or create an `IntervalFileInstance` for an async function.
          * Each function reference gets its own isolated persistent instance.
          */
-        this._getFileInstance = functoolsKit.memoize(([run]) => run, (run, interval, name) => new IntervalFileInstance(run, interval, name));
+        this._getFileInstance = functoolsKit.memoize(([run]) => run, (run, interval, name, key) => new IntervalFileInstance(run, interval, name, key));
         /**
          * Wrap a signal function with in-memory once-per-interval firing.
          *
@@ -53870,21 +54560,30 @@ class IntervalUtils {
          *
          * @param run - Signal function to wrap
          * @param context.interval - Candle interval that controls the firing boundary
-         * @returns Wrapped function with the same signature as `TIntervalFn`, plus a `clear()` method
+         * @param context.key - Optional key generator for argument-based state separation
+         * @returns Wrapped function with the same signature as `F`, plus a `clear()` method
          *
          * @example
          * ```typescript
+         * // Without extra args
          * const fireOnce = Interval.fn(mySignalFn, { interval: "15m" });
+         * await fireOnce("BTCUSDT"); // → T or null  (fn called)
+         * await fireOnce("BTCUSDT"); // → null       (same interval, skipped)
          *
-         * await fireOnce("BTCUSDT", when); // → signal or null  (fn called)
-         * await fireOnce("BTCUSDT", when); // → null            (same interval, skipped)
+         * // With extra args and key
+         * const fireOnce = Interval.fn(mySignalFn, {
+         *   interval: "15m",
+         *   key: ([symbol, period]) => `${symbol}_${period}`,
+         * });
+         * await fireOnce("BTCUSDT", 14); // → T or null
+         * await fireOnce("BTCUSDT", 28); // → T or null (separate state)
          * ```
          */
         this.fn = (run, context) => {
             backtest.loggerService.info(INTERVAL_METHOD_NAME_FN, { context });
-            const wrappedFn = (symbol, _when) => {
-                const instance = this._getInstance(run, context.interval);
-                return instance.run(symbol);
+            const wrappedFn = (...args) => {
+                const instance = this._getInstance(run, context.interval, context.key);
+                return instance.run(...args);
             };
             wrappedFn.clear = () => {
                 backtest.loggerService.info(INTERVAL_METHOD_NAME_FN_CLEAR);
@@ -53898,6 +54597,14 @@ class IntervalUtils {
                 }
                 this._getInstance.get(run)?.clear();
             };
+            wrappedFn.gc = () => {
+                backtest.loggerService.info(INTERVAL_METHOD_NAME_FN_GC);
+                if (!ExecutionContextService.hasContext()) {
+                    backtest.loggerService.warn(`${INTERVAL_METHOD_NAME_FN_GC} called without execution context, skipping`);
+                    return;
+                }
+                return this._getInstance.get(run)?.gc();
+            };
             return wrappedFn;
         };
         /**
@@ -53910,27 +54617,32 @@ class IntervalUtils {
          * The `run` function reference is used as the memoization key for the underlying
          * `IntervalFileInstance`, so each unique function reference gets its own isolated instance.
          *
-         * @template T - Async function type to wrap
+         * @template F - Concrete async function type
          * @param run - Async signal function to wrap with persistent once-per-interval firing
          * @param context.interval - Candle interval that controls the firing boundary
          * @param context.name - Human-readable bucket name; becomes the directory prefix
-         * @returns Wrapped function with the same signature as `T`, plus an async `clear()` method
-         *   that deletes persisted records from disk and disposes the memoized instance
+         * @param context.key - Optional entity key generator. Receives `[symbol, alignMs, ...rest]`.
+         *                      Default: `([symbol, alignMs]) => \`${symbol}_${alignMs}\``
+         * @returns Wrapped function with the same signature as `F`, plus an async `clear()` method
          *
          * @example
          * ```typescript
          * const fetchSignal = async (symbol: string, period: number) => { ... };
-         * const fireOnce = Interval.file(fetchSignal, { interval: "1h", name: "fetchSignal" });
-         * await fireOnce.clear(); // delete disk records so the function fires again next call
+         * const fireOnce = Interval.file(fetchSignal, {
+         *   interval: "1h",
+         *   name: "fetchSignal",
+         *   key: ([symbol, alignMs, period]) => `${symbol}_${alignMs}_${period}`,
+         * });
+         * await fireOnce("BTCUSDT", 14);
          * ```
          */
         this.file = (run, context) => {
             backtest.loggerService.info(INTERVAL_METHOD_NAME_FILE, { context });
             {
-                this._getFileInstance(run, context.interval, context.name);
+                this._getFileInstance(run, context.interval, context.name, context.key);
             }
             const wrappedFn = (...args) => {
-                const instance = this._getFileInstance(run, context.interval, context.name);
+                const instance = this._getFileInstance(run, context.interval, context.name, context.key);
                 return instance.run(...args);
             };
             wrappedFn.clear = async () => {
@@ -53957,10 +54669,10 @@ class IntervalUtils {
         this.dispose = (run) => {
             backtest.loggerService.info(INTERVAL_METHOD_NAME_DISPOSE, { run });
             this._getInstance.clear(run);
+            this._getFileInstance.clear(run);
         };
         /**
-         * Clears all memoized `IntervalFnInstance` and `IntervalFileInstance` objects and
-         * resets the `IntervalFileInstance` index counter.
+         * Clears all memoized `IntervalFnInstance` and `IntervalFileInstance` objects.
          * Call this when `process.cwd()` changes between strategy iterations
          * so new instances are created with the updated base path.
          */
@@ -53968,7 +54680,15 @@ class IntervalUtils {
             backtest.loggerService.info(INTERVAL_METHOD_NAME_CLEAR);
             this._getInstance.clear();
             this._getFileInstance.clear();
-            IntervalFileInstance.clearCounter();
+        };
+        /**
+         * Resets the IntervalFileInstance index counter to zero.
+         * This is useful when process.cwd() changes between strategy iterations to ensure
+         * that new IntervalFileInstance objects start with index 0 and do not collide with old instances.
+         */
+        this.resetCounter = () => {
+            backtest.loggerService.info(INTERVAL_METHOD_NAME_RESET_COUNTER);
+            IntervalFileInstance.resetCounter();
         };
     }
 }
@@ -55212,9 +55932,13 @@ exports.getPositionEffectivePrice = getPositionEffectivePrice;
 exports.getPositionEntries = getPositionEntries;
 exports.getPositionEntryOverlap = getPositionEntryOverlap;
 exports.getPositionEstimateMinutes = getPositionEstimateMinutes;
+exports.getPositionHighestMaxDrawdownPnlCost = getPositionHighestMaxDrawdownPnlCost;
+exports.getPositionHighestMaxDrawdownPnlPercentage = getPositionHighestMaxDrawdownPnlPercentage;
 exports.getPositionHighestPnlCost = getPositionHighestPnlCost;
 exports.getPositionHighestPnlPercentage = getPositionHighestPnlPercentage;
 exports.getPositionHighestProfitBreakeven = getPositionHighestProfitBreakeven;
+exports.getPositionHighestProfitDistancePnlCost = getPositionHighestProfitDistancePnlCost;
+exports.getPositionHighestProfitDistancePnlPercentage = getPositionHighestProfitDistancePnlPercentage;
 exports.getPositionHighestProfitMinutes = getPositionHighestProfitMinutes;
 exports.getPositionHighestProfitPrice = getPositionHighestProfitPrice;
 exports.getPositionHighestProfitTimestamp = getPositionHighestProfitTimestamp;