backtest-kit 6.11.0 → 6.13.0

package/build/index.cjs

@@ -1002,6 +1002,12 @@ const PERSIST_MEMORY_UTILS_METHOD_NAME_LIST_DATA = "PersistMemoryUtils.listMemor
 const PERSIST_MEMORY_UTILS_METHOD_NAME_HAS_DATA = "PersistMemoryUtils.hasMemoryData";
 const PERSIST_MEMORY_UTILS_METHOD_NAME_CLEAR = "PersistMemoryUtils.clear";
 const PERSIST_MEMORY_UTILS_METHOD_NAME_DISPOSE = "PersistMemoryUtils.dispose";
+const PERSIST_RECENT_UTILS_METHOD_NAME_USE_PERSIST_RECENT_ADAPTER = "PersistRecentUtils.usePersistRecentAdapter";
+const PERSIST_RECENT_UTILS_METHOD_NAME_READ_DATA = "PersistRecentUtils.readRecentData";
+const PERSIST_RECENT_UTILS_METHOD_NAME_WRITE_DATA = "PersistRecentUtils.writeRecentData";
+const PERSIST_RECENT_UTILS_METHOD_NAME_USE_JSON = "PersistRecentUtils.useJson";
+const PERSIST_RECENT_UTILS_METHOD_NAME_USE_DUMMY = "PersistRecentUtils.useDummy";
+const PERSIST_RECENT_UTILS_METHOD_NAME_CLEAR = "PersistRecentUtils.clear";
 const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
 const BASE_UNLINK_RETRY_COUNT = 5;
 const BASE_UNLINK_RETRY_DELAY = 1000;
@@ -2848,6 +2854,115 @@ class PersistMemoryUtils {
  * ```
  */
 const PersistMemoryAdapter = new PersistMemoryUtils();
+/**
+ * Utility class for managing recent signal persistence.
+ *
+ * Features:
+ * - Memoized storage instances per (symbol, strategyName, exchangeName, frameName) context
+ * - Custom adapter support
+ * - Atomic read/write operations
+ * - Crash-safe recent signal state management
+ *
+ * Used by RecentPersistBacktestUtils/RecentPersistLiveUtils for recent signal persistence.
+ */
+class PersistRecentUtils {
+    constructor() {
+        this.PersistRecentFactory = PersistBase;
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => this.createKeyParts(symbol, strategyName, exchangeName, frameName, backtest).join(":"), (symbol, strategyName, exchangeName, frameName, backtest) => Reflect.construct(this.PersistRecentFactory, [
+            this.createKeyParts(symbol, strategyName, exchangeName, frameName, backtest).join("_"),
+            `./dump/data/recent/`,
+        ]));
+        /**
+         * Reads the latest persisted recent signal for a given context.
+         *
+         * Returns null if no recent signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @returns Promise resolving to recent signal or null
+         */
+        this.readRecentData = async (symbol, strategyName, exchangeName, frameName, backtest) => {
+            LOGGER_SERVICE$7.info(PERSIST_RECENT_UTILS_METHOD_NAME_READ_DATA);
+            const key = this.createKeyParts(symbol, strategyName, exchangeName, frameName, backtest).join(":");
+            const isInitial = !this.getStorage.has(key);
+            const stateStorage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
+            await stateStorage.waitForInit(isInitial);
+            if (await stateStorage.hasValue(symbol)) {
+                return await stateStorage.readValue(symbol);
+            }
+            return null;
+        };
+        /**
+         * Writes the latest recent signal to disk with atomic file writes.
+         *
+         * Uses symbol as the entity ID within the per-context storage instance.
+         * Uses atomic writes to prevent corruption on crashes.
+         *
+         * @param signalRow - Recent signal data to persist
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @returns Promise that resolves when write is complete
+         */
+        this.writeRecentData = async (signalRow, symbol, strategyName, exchangeName, frameName, backtest) => {
+            LOGGER_SERVICE$7.info(PERSIST_RECENT_UTILS_METHOD_NAME_WRITE_DATA);
+            const key = this.createKeyParts(symbol, strategyName, exchangeName, frameName, backtest).join(":");
+            const isInitial = !this.getStorage.has(key);
+            const stateStorage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
+            await stateStorage.waitForInit(isInitial);
+            await stateStorage.writeValue(symbol, signalRow);
+        };
+    }
+    createKeyParts(symbol, strategyName, exchangeName, frameName, backtest) {
+        const parts = [symbol, strategyName, exchangeName];
+        if (frameName)
+            parts.push(frameName);
+        parts.push(backtest ? "backtest" : "live");
+        return parts;
+    }
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     */
+    usePersistRecentAdapter(Ctor) {
+        LOGGER_SERVICE$7.info(PERSIST_RECENT_UTILS_METHOD_NAME_USE_PERSIST_RECENT_ADAPTER);
+        this.PersistRecentFactory = Ctor;
+    }
+    /**
+     * Clears the memoized storage cache.
+     * Call this when process.cwd() changes between strategy iterations
+     * so new storage instances are created with the updated base path.
+     */
+    clear() {
+        LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_CLEAR);
+        this.getStorage.clear();
+    }
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistRecentAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistRecentAdapter(PersistDummy);
+    }
+}
+/**
+ * Global singleton instance of PersistRecentUtils.
+ * Used by RecentPersistBacktestUtils/RecentPersistLiveUtils for recent signal persistence.
+ */
+const PersistRecentAdapter = new PersistRecentUtils();
 
 var _a$2, _b$2;
 const BUSY_DELAY = 100;
@@ -6593,7 +6708,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, cancelId) => {
+const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePrice, closeTimestamp, reason, cancelId, cancelNote) => {
     self.params.logger.info("ClientStrategy backtest scheduled signal cancelled", {
         symbol: self.params.execution.context.symbol,
         signalId: scheduled.id,
@@ -6618,7 +6733,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,
+            note: cancelNote ?? scheduled.note,
         });
     }
     await CALL_CANCEL_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, averagePrice, closeTimestamp, self.params.execution.context.backtest);
@@ -6785,7 +6900,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,
+        note: closedSignal.closeNote ?? 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);
@@ -6832,7 +6947,8 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles, fra
         if (self._cancelledSignal) {
             // Сигнал был отменен через cancel() в onSchedulePing
             const cancelId = self._cancelledSignal.cancelId;
-            const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "user", cancelId);
+            const cancelNote = self._cancelledSignal.cancelNote;
+            const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "user", cancelId, cancelNote);
             return { outcome: "cancelled", result };
         }
         // КРИТИЧНО: Проверяем был ли сигнал активирован пользователем через activateScheduled()
@@ -6886,7 +7002,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,
+                    note: activatedSignal.activateNote ?? activatedSignal.note,
                 });
                 return { outcome: "pending" };
             }
@@ -6918,7 +7034,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles, fra
                 pendingAt: publicSignalForCommit.pendingAt,
                 totalEntries: publicSignalForCommit.totalEntries,
                 totalPartials: publicSignalForCommit.totalPartials,
-                note: publicSignalForCommit.note,
+                note: activatedSignal.activateNote ?? 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);
@@ -8039,6 +8155,44 @@ class ClientStrategy {
         const currentPnl = toProfitLossDto(this._pendingSignal, currentPrice);
         return Math.max(0, currentPnl.pnlCost - this._pendingSignal._fall.pnlCost);
     }
+    /**
+     * Returns the peak-to-trough PnL percentage distance between the position's highest profit and deepest drawdown.
+     *
+     * Measures the total swing from the stored `_peak.pnlPercentage` to the stored `_fall.pnlPercentage`.
+     * Computed as: max(0, peakPnlPercentage - fallPnlPercentage).
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @returns Promise resolving to peak-to-trough PnL percentage distance (≥ 0) or null
+     */
+    async getMaxDrawdownDistancePnlPercentage(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy getMaxDrawdownDistancePnlPercentage", { symbol, currentPrice });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return Math.max(0, this._pendingSignal._peak.pnlPercentage - this._pendingSignal._fall.pnlPercentage);
+    }
+    /**
+     * Returns the peak-to-trough PnL cost distance between the position's highest profit and deepest drawdown.
+     *
+     * Measures the total swing from the stored `_peak.pnlCost` to the stored `_fall.pnlCost`.
+     * Computed as: max(0, peakPnlCost - fallPnlCost).
+     *
+     * Returns null if no pending signal exists.
+     *
+     * @param symbol - Trading pair symbol
+     * @param currentPrice - Current market price
+     * @returns Promise resolving to peak-to-trough PnL cost distance (≥ 0) or null
+     */
+    async getMaxDrawdownDistancePnlCost(symbol, currentPrice) {
+        this.params.logger.debug("ClientStrategy getMaxDrawdownDistancePnlCost", { symbol, currentPrice });
+        if (!this._pendingSignal) {
+            return null;
+        }
+        return Math.max(0, this._pendingSignal._peak.pnlCost - this._pendingSignal._fall.pnlCost);
+    }
     /**
      * Performs a single tick of strategy execution.
      *
@@ -8103,7 +8257,7 @@ class ClientStrategy {
                 totalPartials: cancelledSignal._partial?.length ?? 0,
                 originalPriceOpen: cancelledSignal.priceOpen,
                 pnl: toProfitLossDto(cancelledSignal, currentPrice),
-                note: cancelledSignal.note,
+                note: cancelledSignal.cancelNote ?? cancelledSignal.note,
             });
             // Call onCancel callback
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -8157,7 +8311,7 @@ class ClientStrategy {
                 totalPartials: closedSignal._partial?.length ?? 0,
                 originalPriceOpen: closedSignal.priceOpen,
                 pnl: toProfitLossDto(closedSignal, currentPrice),
-                note: closedSignal.note,
+                note: closedSignal.closeNote ?? closedSignal.note,
             });
             // Call onClose callback
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -8239,7 +8393,7 @@ class ClientStrategy {
                     totalPartials: activatedSignal._partial?.length ?? 0,
                     originalPriceOpen: activatedSignal.priceOpen,
                     pnl: toProfitLossDto(activatedSignal, currentPrice),
-                    note: activatedSignal.note,
+                    note: activatedSignal.activateNote ?? activatedSignal.note,
                 });
                 return await RETURN_IDLE_FN(this, currentPrice);
             }
@@ -8270,7 +8424,7 @@ class ClientStrategy {
                 pendingAt: publicSignalForCommit.pendingAt,
                 totalEntries: publicSignalForCommit.totalEntries,
                 totalPartials: publicSignalForCommit.totalPartials,
-                note: publicSignalForCommit.note,
+                note: activatedSignal.activateNote ?? publicSignalForCommit.note,
             });
             // Call onOpen callback
             await CALL_OPEN_CALLBACKS_FN(this, this.params.execution.context.symbol, pendingSignal, currentPrice, currentTime, this.params.execution.context.backtest);
@@ -8406,7 +8560,7 @@ class ClientStrategy {
                 totalPartials: cancelledSignal._partial?.length ?? 0,
                 originalPriceOpen: cancelledSignal.priceOpen,
                 pnl: toProfitLossDto(cancelledSignal, currentPrice),
-                note: cancelledSignal.note,
+                note: cancelledSignal.cancelNote ?? cancelledSignal.note,
             });
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             const cancelledResult = {
@@ -8461,7 +8615,7 @@ class ClientStrategy {
                 totalPartials: closedSignal._partial?.length ?? 0,
                 originalPriceOpen: closedSignal.priceOpen,
                 pnl: toProfitLossDto(closedSignal, currentPrice),
-                note: closedSignal.note,
+                note: closedSignal.closeNote ?? closedSignal.note,
             });
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
@@ -8645,7 +8799,8 @@ class ClientStrategy {
      * // Strategy continues, can generate new signals
      * ```
      */
-    async cancelScheduled(symbol, backtest, cancelId) {
+    async cancelScheduled(symbol, backtest, payload) {
+        const cancelId = payload.id;
         this.params.logger.debug("ClientStrategy cancelScheduled", {
             symbol,
             hasScheduledSignal: this._scheduledSignal !== null,
@@ -8657,6 +8812,7 @@ class ClientStrategy {
         if (this._scheduledSignal) {
             this._cancelledSignal = Object.assign({}, this._scheduledSignal, {
                 cancelId,
+                cancelNote: payload.note,
             });
             this._scheduledSignal = null;
         }
@@ -8688,7 +8844,8 @@ class ClientStrategy {
      * // Scheduled signal becomes pending signal immediately
      * ```
      */
-    async activateScheduled(symbol, backtest, activateId) {
+    async activateScheduled(symbol, backtest, payload) {
+        const activateId = payload.id;
         this.params.logger.debug("ClientStrategy activateScheduled", {
             symbol,
             hasScheduledSignal: this._scheduledSignal !== null,
@@ -8706,6 +8863,7 @@ class ClientStrategy {
         if (this._scheduledSignal) {
             this._activatedSignal = Object.assign({}, this._scheduledSignal, {
                 activateId,
+                activateNote: payload.note,
             });
             this._scheduledSignal = null;
         }
@@ -8737,7 +8895,8 @@ class ClientStrategy {
      * // Strategy continues, can generate new signals
      * ```
      */
-    async closePending(symbol, backtest, closeId) {
+    async closePending(symbol, backtest, payload) {
+        const closeId = payload.id;
         this.params.logger.debug("ClientStrategy closePending", {
             symbol,
             hasPendingSignal: this._pendingSignal !== null,
@@ -8748,6 +8907,7 @@ class ClientStrategy {
         if (this._pendingSignal) {
             this._closedSignal = Object.assign({}, this._pendingSignal, {
                 closeId,
+                closeNote: payload.note,
             });
             this._pendingSignal = null;
         }
@@ -10130,7 +10290,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$t = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$u = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -10397,7 +10557,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$t(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
+        this.getStrategy = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$u(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
             const { riskName = "", riskList = [], getSignal, interval = STRATEGY_DEFAULT_INTERVAL, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
@@ -11238,6 +11398,48 @@ class StrategyConnectionService {
             const currentPrice = await this.priceMetaService.getCurrentPrice(symbol, context, backtest);
             return await strategy.getPositionHighestMaxDrawdownPnlCost(symbol, currentPrice);
         };
+        /**
+         * Returns the peak-to-trough PnL percentage distance between the position's highest profit and deepest drawdown.
+         *
+         * Resolves current price via priceMetaService and delegates to
+         * ClientStrategy.getMaxDrawdownDistancePnlPercentage().
+         * 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 peak-to-trough PnL percentage distance (≥ 0) or null
+         */
+        this.getMaxDrawdownDistancePnlPercentage = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getMaxDrawdownDistancePnlPercentage", {
+                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.getMaxDrawdownDistancePnlPercentage(symbol, currentPrice);
+        };
+        /**
+         * Returns the peak-to-trough PnL cost distance between the position's highest profit and deepest drawdown.
+         *
+         * Resolves current price via priceMetaService and delegates to
+         * ClientStrategy.getMaxDrawdownDistancePnlCost().
+         * 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 peak-to-trough PnL cost distance (≥ 0) or null
+         */
+        this.getMaxDrawdownDistancePnlCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService getMaxDrawdownDistancePnlCost", {
+                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.getMaxDrawdownDistancePnlCost(symbol, currentPrice);
+        };
         /**
          * Disposes the ClientStrategy instance for the given context.
          *
@@ -11276,7 +11478,7 @@ class StrategyConnectionService {
                 }
                 return;
             }
-            const key = CREATE_KEY_FN$t(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$u(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             if (!this.getStrategy.has(key)) {
                 return;
             }
@@ -11297,17 +11499,17 @@ class StrategyConnectionService {
          * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
          * @param ctx - Context with strategyName, exchangeName, frameName
-         * @param cancelId - Optional cancellation ID for user-initiated cancellations
+         * @param payload - Optional commit payload with id and note
          * @returns Promise that resolves when scheduled signal is cancelled
          */
-        this.cancelScheduled = async (backtest, symbol, context, cancelId) => {
+        this.cancelScheduled = async (backtest, symbol, context, payload = {}) => {
             this.loggerService.log("strategyConnectionService cancelScheduled", {
                 symbol,
                 context,
-                cancelId,
+                payload,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.cancelScheduled(symbol, backtest, cancelId);
+            await strategy.cancelScheduled(symbol, backtest, payload);
         };
         /**
          * Closes the pending signal without stopping the strategy.
@@ -11322,17 +11524,17 @@ class StrategyConnectionService {
          * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
          * @param context - Context with strategyName, exchangeName, frameName
-         * @param closeId - Optional close ID for user-initiated closes
+         * @param payload - Optional commit payload with id and note
          * @returns Promise that resolves when pending signal is closed
          */
-        this.closePending = async (backtest, symbol, context, closeId) => {
+        this.closePending = async (backtest, symbol, context, payload = {}) => {
             this.loggerService.log("strategyConnectionService closePending", {
                 symbol,
                 context,
-                closeId,
+                payload,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.closePending(symbol, backtest, closeId);
+            await strategy.closePending(symbol, backtest, payload);
         };
         /**
          * Checks whether `partialProfit` would succeed without executing it.
@@ -11611,7 +11813,7 @@ class StrategyConnectionService {
          * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
          * @param context - Execution context with strategyName, exchangeName, frameName
-         * @param activateId - Optional identifier for the activation reason
+         * @param payload - Optional commit payload with id and note
          * @returns Promise that resolves when activation flag is set
          *
          * @example
@@ -11621,19 +11823,19 @@ class StrategyConnectionService {
          *   false,
          *   "BTCUSDT",
          *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" },
-         *   "manual-activation"
+         *   { id: "manual-activation" }
          * );
          * ```
          */
-        this.activateScheduled = async (backtest, symbol, context, activateId) => {
+        this.activateScheduled = async (backtest, symbol, context, payload = {}) => {
             this.loggerService.log("strategyConnectionService activateScheduled", {
                 symbol,
                 context,
                 backtest,
-                activateId,
+                payload,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            return await strategy.activateScheduled(symbol, backtest, activateId);
+            return await strategy.activateScheduled(symbol, backtest, payload);
         };
         /**
          * Checks whether `averageBuy` would succeed without executing it.
@@ -12445,7 +12647,7 @@ class ClientRisk {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$s = (riskName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$t = (riskName, exchangeName, frameName, backtest) => {
     const parts = [riskName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -12545,7 +12747,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$s(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
+        this.getRisk = functoolsKit.memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$t(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
             const schema = this.riskSchemaService.get(riskName);
             return new ClientRisk({
                 ...schema,
@@ -12614,7 +12816,7 @@ class RiskConnectionService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$s(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$t(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getRisk.clear(key);
             }
             else {
@@ -13658,7 +13860,7 @@ class ClientAction {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$r = (actionName, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$s = (actionName, strategyName, exchangeName, frameName, backtest) => {
     const parts = [actionName, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -13710,7 +13912,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$r(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
+        this.getAction = functoolsKit.memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$s(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
             const schema = this.actionSchemaService.get(actionName);
             return new ClientAction({
                 ...schema,
@@ -13921,7 +14123,7 @@ class ActionConnectionService {
                 await Promise.all(actions.map(async (action) => await action.dispose()));
                 return;
             }
-            const key = CREATE_KEY_FN$r(payload.actionName, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$s(payload.actionName, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             if (!this.getAction.has(key)) {
                 return;
             }
@@ -13939,7 +14141,7 @@ const METHOD_NAME_VALIDATE$2 = "exchangeCoreService validate";
  * @param exchangeName - Exchange name
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$q = (exchangeName) => {
+const CREATE_KEY_FN$r = (exchangeName) => {
     return exchangeName;
 };
 /**
@@ -13963,7 +14165,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$q(exchangeName), async (exchangeName) => {
+        this.validate = functoolsKit.memoize(([exchangeName]) => CREATE_KEY_FN$r(exchangeName), async (exchangeName) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$2, {
                 exchangeName,
             });
@@ -14215,7 +14417,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$p = (context) => {
+const CREATE_KEY_FN$q = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -14247,7 +14449,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$p(context), async (context) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$q(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$1, {
                 context,
             });
@@ -14668,18 +14870,18 @@ class StrategyCoreService {
          * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
          * @param ctx - Context with strategyName, exchangeName, frameName
-         * @param cancelId - Optional cancellation ID for user-initiated cancellations
+         * @param payload - Optional commit payload with id and note
          * @returns Promise that resolves when scheduled signal is cancelled
          */
-        this.cancelScheduled = async (backtest, symbol, context, cancelId) => {
+        this.cancelScheduled = async (backtest, symbol, context, payload = {}) => {
             this.loggerService.log("strategyCoreService cancelScheduled", {
                 symbol,
                 context,
                 backtest,
-                cancelId,
+                payload,
             });
             await this.validate(context);
-            return await this.strategyConnectionService.cancelScheduled(backtest, symbol, context, cancelId);
+            return await this.strategyConnectionService.cancelScheduled(backtest, symbol, context, payload);
         };
         /**
          * Closes the pending signal without stopping the strategy.
@@ -14695,18 +14897,18 @@ class StrategyCoreService {
          * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
          * @param context - Context with strategyName, exchangeName, frameName
-         * @param closeId - Optional close ID for user-initiated closes
+         * @param payload - Optional commit payload with id and note
          * @returns Promise that resolves when pending signal is closed
          */
-        this.closePending = async (backtest, symbol, context, closeId) => {
+        this.closePending = async (backtest, symbol, context, payload = {}) => {
             this.loggerService.log("strategyCoreService closePending", {
                 symbol,
                 context,
                 backtest,
-                closeId,
+                payload,
             });
             await this.validate(context);
-            return await this.strategyConnectionService.closePending(backtest, symbol, context, closeId);
+            return await this.strategyConnectionService.closePending(backtest, symbol, context, payload);
         };
         /**
          * Disposes the ClientStrategy instance for the given context.
@@ -15051,7 +15253,7 @@ class StrategyCoreService {
          * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
          * @param context - Execution context with strategyName, exchangeName, frameName
-         * @param activateId - Optional identifier for the activation reason
+         * @param payload - Optional commit payload with id and note
          * @returns Promise that resolves when activation flag is set
          *
          * @example
@@ -15061,19 +15263,19 @@ class StrategyCoreService {
          *   false,
          *   "BTCUSDT",
          *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" },
-         *   "manual-activation"
+         *   { id: "manual-activation" }
          * );
          * ```
          */
-        this.activateScheduled = async (backtest, symbol, context, activateId) => {
+        this.activateScheduled = async (backtest, symbol, context, payload = {}) => {
             this.loggerService.log("strategyCoreService activateScheduled", {
                 symbol,
                 context,
                 backtest,
-                activateId,
+                payload,
             });
             await this.validate(context);
-            return await this.strategyConnectionService.activateScheduled(backtest, symbol, context, activateId);
+            return await this.strategyConnectionService.activateScheduled(backtest, symbol, context, payload);
         };
         /**
          * Checks whether `averageBuy` would succeed without executing it.
@@ -15475,6 +15677,44 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.getPositionHighestMaxDrawdownPnlCost(backtest, symbol, context);
         };
+        /**
+         * Returns the peak-to-trough PnL percentage distance between the position's highest profit and deepest drawdown.
+         *
+         * Delegates to StrategyConnectionService.getMaxDrawdownDistancePnlPercentage().
+         * 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 peak-to-trough PnL percentage distance (≥ 0) or null
+         */
+        this.getMaxDrawdownDistancePnlPercentage = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getMaxDrawdownDistancePnlPercentage", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getMaxDrawdownDistancePnlPercentage(backtest, symbol, context);
+        };
+        /**
+         * Returns the peak-to-trough PnL cost distance between the position's highest profit and deepest drawdown.
+         *
+         * Delegates to StrategyConnectionService.getMaxDrawdownDistancePnlCost().
+         * 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 peak-to-trough PnL cost distance (≥ 0) or null
+         */
+        this.getMaxDrawdownDistancePnlCost = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService getMaxDrawdownDistancePnlCost", {
+                symbol,
+                context,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.getMaxDrawdownDistancePnlCost(backtest, symbol, context);
+        };
     }
 }
 
@@ -15547,7 +15787,7 @@ class SizingGlobalService {
  * @param context - Context with riskName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$o = (context) => {
+const CREATE_KEY_FN$p = (context) => {
     const parts = [context.riskName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -15573,7 +15813,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$o(context), async (context) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$p(context), async (context) => {
             this.loggerService.log("riskGlobalService validate", {
                 context,
             });
@@ -15651,7 +15891,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$n = (context) => {
+const CREATE_KEY_FN$o = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -15695,7 +15935,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$n(context), async (context) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$o(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE, {
                 context,
             });
@@ -20738,7 +20978,7 @@ const ReportWriter = new ReportWriterAdapter();
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$m = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$n = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -20984,7 +21224,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$m(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$a(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$n(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$a(symbol, strategyName, exchangeName, frameName));
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -21141,7 +21381,7 @@ class BacktestMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$m(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$n(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -21203,7 +21443,7 @@ class BacktestMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$l = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$m = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -21698,7 +21938,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$l(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$9(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$m(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$9(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to live signal emitter to receive tick events.
          * Protected against multiple subscriptions.
@@ -21916,7 +22156,7 @@ class LiveMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$l(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$m(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -21936,7 +22176,7 @@ class LiveMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$k = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$l = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -22225,7 +22465,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$k(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$l(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$8(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to signal emitter to receive scheduled signal events.
          * Protected against multiple subscriptions.
@@ -22428,7 +22668,7 @@ class ScheduleMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$k(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$l(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -22448,7 +22688,7 @@ class ScheduleMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$j = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$k = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -22693,7 +22933,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$j(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$k(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.
@@ -22860,7 +23100,7 @@ class PerformanceMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$j(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$k(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -23339,7 +23579,7 @@ class WalkerMarkdownService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$i = (exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$j = (exchangeName, frameName, backtest) => {
     const parts = [exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -23786,7 +24026,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$i(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
+        this.getStorage = functoolsKit.memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$j(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
         /**
          * Subscribes to signal emitter to receive tick events.
          * Protected against multiple subscriptions.
@@ -24004,7 +24244,7 @@ class HeatMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$i(payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$j(payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -25035,7 +25275,7 @@ class ClientPartial {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$h = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$i = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
 /**
  * Creates a callback function for emitting profit events to partialProfitSubject.
  *
@@ -25157,7 +25397,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$h(signalId, backtest), (signalId, backtest) => {
+        this.getPartial = functoolsKit.memoize(([signalId, backtest]) => CREATE_KEY_FN$i(signalId, backtest), (signalId, backtest) => {
             return new ClientPartial({
                 signalId,
                 logger: this.loggerService,
@@ -25247,7 +25487,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$h(data.id, backtest);
+            const key = CREATE_KEY_FN$i(data.id, backtest);
             this.getPartial.clear(key);
         };
     }
@@ -25263,7 +25503,7 @@ class PartialConnectionService {
  * @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);
@@ -25486,7 +25726,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$g(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$6(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, backtest) => new ReportStorage$6(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to partial profit/loss signal emitters to receive events.
          * Protected against multiple subscriptions.
@@ -25696,7 +25936,7 @@ class PartialMarkdownService {
                 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 {
@@ -25712,7 +25952,7 @@ class PartialMarkdownService {
  * @param context - Context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$f = (context) => {
+const CREATE_KEY_FN$g = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -25786,7 +26026,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$f(context), (context, methodName) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$g(context), (context, methodName) => {
             this.loggerService.log("partialGlobalService validate", {
                 context,
                 methodName,
@@ -26241,7 +26481,7 @@ class ClientBreakeven {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$e = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$f = (signalId, backtest) => `${signalId}:${backtest ? "backtest" : "live"}`;
 /**
  * Creates a callback function for emitting breakeven events to breakevenSubject.
  *
@@ -26327,7 +26567,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$e(signalId, backtest), (signalId, backtest) => {
+        this.getBreakeven = functoolsKit.memoize(([signalId, backtest]) => CREATE_KEY_FN$f(signalId, backtest), (signalId, backtest) => {
             return new ClientBreakeven({
                 signalId,
                 logger: this.loggerService,
@@ -26388,7 +26628,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$e(data.id, backtest);
+            const key = CREATE_KEY_FN$f(data.id, backtest);
             this.getBreakeven.clear(key);
         };
     }
@@ -26404,7 +26644,7 @@ class BreakevenConnectionService {
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$d = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$e = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -26579,7 +26819,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$d(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$5(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$e(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$5(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to breakeven signal emitter to receive events.
          * Protected against multiple subscriptions.
@@ -26768,7 +27008,7 @@ class BreakevenMarkdownService {
                 payload,
             });
             if (payload) {
-                const key = CREATE_KEY_FN$d(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$e(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -26784,7 +27024,7 @@ class BreakevenMarkdownService {
  * @param context - Context with strategyName, exchangeName, frameName
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$c = (context) => {
+const CREATE_KEY_FN$d = (context) => {
     const parts = [context.strategyName, context.exchangeName];
     if (context.frameName)
         parts.push(context.frameName);
@@ -26858,7 +27098,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$c(context), (context, methodName) => {
+        this.validate = functoolsKit.memoize(([context]) => CREATE_KEY_FN$d(context), (context, methodName) => {
             this.loggerService.log("breakevenGlobalService validate", {
                 context,
                 methodName,
@@ -27079,7 +27319,7 @@ class ConfigValidationService {
  * @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);
@@ -27246,7 +27486,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$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$4(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to risk rejection emitter to receive rejection events.
          * Protected against multiple subscriptions.
@@ -27435,7 +27675,7 @@ class RiskMarkdownService {
                 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 {
@@ -29074,7 +29314,7 @@ class StrategyReportService {
         /**
          * Logs a cancel-scheduled event when a scheduled signal is cancelled.
          */
-        this.cancelScheduled = async (symbol, isBacktest, context, timestamp, signalId, pnl, totalPartials, cancelId) => {
+        this.cancelScheduled = async (symbol, isBacktest, context, timestamp, signalId, pnl, totalPartials, cancelId, note) => {
             this.loggerService.log("strategyReportService cancelScheduled", {
                 symbol,
                 isBacktest,
@@ -29087,6 +29327,7 @@ class StrategyReportService {
             await ReportWriter.writeData("strategy", {
                 action: "cancel-scheduled",
                 cancelId,
+                note,
                 symbol,
                 timestamp,
                 createdAt,
@@ -29108,7 +29349,7 @@ class StrategyReportService {
         /**
          * Logs a close-pending event when a pending signal is closed.
          */
-        this.closePending = async (symbol, isBacktest, context, timestamp, signalId, pnl, totalPartials, closeId) => {
+        this.closePending = async (symbol, isBacktest, context, timestamp, signalId, pnl, totalPartials, closeId, note) => {
             this.loggerService.log("strategyReportService closePending", {
                 symbol,
                 isBacktest,
@@ -29121,6 +29362,7 @@ class StrategyReportService {
             await ReportWriter.writeData("strategy", {
                 action: "close-pending",
                 closeId,
+                note,
                 symbol,
                 timestamp,
                 createdAt,
@@ -29370,7 +29612,7 @@ class StrategyReportService {
         /**
          * Logs an activate-scheduled event when a scheduled signal is activated early.
          */
-        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, signalId, pnl, totalPartials, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen, activateId) => {
+        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, signalId, pnl, totalPartials, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen, activateId, note) => {
             this.loggerService.log("strategyReportService activateScheduled", {
                 symbol,
                 currentPrice,
@@ -29384,6 +29626,7 @@ class StrategyReportService {
             await ReportWriter.writeData("strategy", {
                 action: "activate-scheduled",
                 activateId,
+                note,
                 currentPrice,
                 symbol,
                 timestamp,
@@ -29477,14 +29720,14 @@ class StrategyReportService {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.signalId, event.pnl, event.totalPartials, event.cancelId));
+            }, event.timestamp, event.signalId, event.pnl, event.totalPartials, event.cancelId, event.note));
             const unClosePending = strategyCommitSubject
                 .filter(({ action }) => action === "close-pending")
                 .connect(async (event) => await this.closePending(event.symbol, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.signalId, event.pnl, event.totalPartials, event.closeId));
+            }, event.timestamp, event.signalId, event.pnl, event.totalPartials, event.closeId, event.note));
             const unPartialProfit = strategyCommitSubject
                 .filter(({ action }) => action === "partial-profit")
                 .connect(async (event) => await this.partialProfit(event.symbol, event.percentToClose, event.currentPrice, event.backtest, {
@@ -29526,7 +29769,7 @@ class StrategyReportService {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.signalId, event.pnl, event.totalPartials, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen, event.activateId));
+            }, event.timestamp, event.signalId, event.pnl, event.totalPartials, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen, event.activateId, event.note));
             const unAverageBuy = strategyCommitSubject
                 .filter(({ action }) => action === "average-buy")
                 .connect(async (event) => await this.averageBuy(event.symbol, event.currentPrice, event.effectivePriceOpen, event.totalEntries, event.backtest, {
@@ -29814,7 +30057,7 @@ class HighestProfitReportService {
  * @returns Colon-separated key string for memoization
  * @internal
  */
-const CREATE_KEY_FN$a = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$b = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -30056,7 +30299,7 @@ class StrategyMarkdownService {
          *
          * @internal
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$a(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$3(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$b(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$3(symbol, strategyName, exchangeName, frameName));
         /**
          * Records a cancel-scheduled event when a scheduled signal is cancelled.
          *
@@ -30065,8 +30308,9 @@ class StrategyMarkdownService {
          * @param context - Strategy context with strategyName, exchangeName, frameName
          * @param timestamp - Timestamp from StrategyCommitContract (execution context time)
          * @param cancelId - Optional identifier for the cancellation reason
+         * @param note - Optional note from commit payload
          */
-        this.cancelScheduled = async (symbol, isBacktest, context, timestamp, signalId, pnl, cancelId) => {
+        this.cancelScheduled = async (symbol, isBacktest, context, timestamp, signalId, pnl, cancelId, note) => {
             this.loggerService.log("strategyMarkdownService cancelScheduled", {
                 symbol,
                 isBacktest,
@@ -30087,6 +30331,7 @@ class StrategyMarkdownService {
                 action: "cancel-scheduled",
                 pnl,
                 cancelId,
+                note,
                 createdAt,
                 backtest: isBacktest,
             });
@@ -30099,8 +30344,9 @@ class StrategyMarkdownService {
          * @param context - Strategy context with strategyName, exchangeName, frameName
          * @param timestamp - Timestamp from StrategyCommitContract (execution context time)
          * @param closeId - Optional identifier for the close reason
+         * @param note - Optional note from commit payload
          */
-        this.closePending = async (symbol, isBacktest, context, timestamp, signalId, pnl, closeId) => {
+        this.closePending = async (symbol, isBacktest, context, timestamp, signalId, pnl, closeId, note) => {
             this.loggerService.log("strategyMarkdownService closePending", {
                 symbol,
                 isBacktest,
@@ -30121,6 +30367,7 @@ class StrategyMarkdownService {
                 action: "close-pending",
                 pnl,
                 closeId,
+                note,
                 createdAt,
                 backtest: isBacktest,
             });
@@ -30419,8 +30666,9 @@ class StrategyMarkdownService {
          * @param scheduledAt - Signal creation timestamp in milliseconds
          * @param pendingAt - Pending timestamp in milliseconds
          * @param activateId - Optional identifier for the activation reason
+         * @param note - Optional note from commit payload
          */
-        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, signalId, pnl, totalPartials, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen, activateId) => {
+        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, signalId, pnl, totalPartials, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, totalEntries, originalPriceOpen, activateId, note) => {
             this.loggerService.log("strategyMarkdownService activateScheduled", {
                 symbol,
                 currentPrice,
@@ -30443,6 +30691,7 @@ class StrategyMarkdownService {
                 pnl,
                 totalPartials,
                 activateId,
+                note,
                 currentPrice,
                 createdAt,
                 backtest: isBacktest,
@@ -30624,7 +30873,7 @@ class StrategyMarkdownService {
         this.clear = async (payload) => {
             this.loggerService.log("strategyMarkdownService clear", { payload });
             if (payload) {
-                const key = CREATE_KEY_FN$a(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$b(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -30647,14 +30896,14 @@ class StrategyMarkdownService {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.signalId, event.pnl, event.cancelId));
+            }, event.timestamp, event.signalId, event.pnl, event.cancelId, event.note));
             const unClosePending = strategyCommitSubject
                 .filter(({ action }) => action === "close-pending")
                 .connect(async (event) => await this.closePending(event.symbol, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.signalId, event.pnl, event.closeId));
+            }, event.timestamp, event.signalId, event.pnl, event.closeId, event.note));
             const unPartialProfit = strategyCommitSubject
                 .filter(({ action }) => action === "partial-profit")
                 .connect(async (event) => await this.partialProfit(event.symbol, event.percentToClose, event.currentPrice, event.backtest, {
@@ -30696,7 +30945,7 @@ class StrategyMarkdownService {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp, event.signalId, event.pnl, event.totalPartials, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen, event.activateId));
+            }, event.timestamp, event.signalId, event.pnl, event.totalPartials, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.totalEntries, event.originalPriceOpen, event.activateId, event.note));
             const unAverageBuy = strategyCommitSubject
                 .filter(({ action }) => action === "average-buy")
                 .connect(async (event) => await this.averageBuy(event.symbol, event.currentPrice, event.effectivePriceOpen, event.totalEntries, event.backtest, {
@@ -30732,7 +30981,7 @@ class StrategyMarkdownService {
  * Creates a unique key for memoizing ReportStorage instances.
  * Key format: "symbol:strategyName:exchangeName[:frameName]:backtest|live"
  */
-const CREATE_KEY_FN$9 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$a = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -30925,7 +31174,7 @@ let ReportStorage$2 = class ReportStorage {
 class SyncMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        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$2(symbol, strategyName, exchangeName, frameName, backtest));
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$a(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$2(symbol, strategyName, exchangeName, frameName, backtest));
         /**
          * Subscribes to `syncSubject` to start receiving `SignalSyncContract` events.
          * Protected against multiple subscriptions via `singleshot` — subsequent calls
@@ -31121,7 +31370,7 @@ class SyncMarkdownService {
         this.clear = async (payload) => {
             this.loggerService.log("syncMarkdownService clear", { payload });
             if (payload) {
-                const key = CREATE_KEY_FN$9(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+                const key = CREATE_KEY_FN$a(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -31134,7 +31383,7 @@ class SyncMarkdownService {
 /**
  * Creates a unique memoization key for a symbol-strategy-exchange-frame-backtest combination.
  */
-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);
@@ -31310,7 +31559,7 @@ let ReportStorage$1 = class ReportStorage {
 class HighestProfitMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$8(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$9(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$1(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to `highestProfitSubject` to start receiving `HighestProfitContract`
          * events. Protected against multiple subscriptions via `singleshot` — subsequent
@@ -31476,7 +31725,7 @@ class HighestProfitMarkdownService {
         this.clear = async (payload) => {
             this.loggerService.log("highestProfitMarkdownService clear", { 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 {
@@ -31498,7 +31747,7 @@ const LISTEN_TIMEOUT$1 = 120000;
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$7 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+const CREATE_KEY_FN$8 = (symbol, strategyName, exchangeName, frameName, backtest) => {
     const parts = [symbol, strategyName, exchangeName];
     if (frameName)
         parts.push(frameName);
@@ -31541,7 +31790,7 @@ class PriceMetaService {
          * Each subject holds the latest currentPrice emitted by the strategy iterator for that key.
          * Instances are cached until clear() is called.
          */
-        this.getSource = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$7(symbol, strategyName, exchangeName, frameName, backtest), () => new functoolsKit.BehaviorSubject());
+        this.getSource = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$8(symbol, strategyName, exchangeName, frameName, backtest), () => new functoolsKit.BehaviorSubject());
         /**
          * Returns the current market price for the given symbol and context.
          *
@@ -31570,10 +31819,10 @@ class PriceMetaService {
             if (source.data) {
                 return source.data;
             }
-            console.warn(`PriceMetaService: No currentPrice available for ${CREATE_KEY_FN$7(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}. Trying to fetch from strategy iterator as a fallback...`);
+            console.warn(`PriceMetaService: No currentPrice available for ${CREATE_KEY_FN$8(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}. Trying to fetch from strategy iterator as a fallback...`);
             const currentPrice = await functoolsKit.waitForNext(source, (data) => !!data, LISTEN_TIMEOUT$1);
             if (typeof currentPrice === "symbol") {
-                throw new Error(`PriceMetaService: Timeout while waiting for currentPrice for ${CREATE_KEY_FN$7(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}`);
+                throw new Error(`PriceMetaService: Timeout while waiting for currentPrice for ${CREATE_KEY_FN$8(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}`);
             }
             return currentPrice;
         };
@@ -31615,7 +31864,7 @@ class PriceMetaService {
                 this.getSource.clear();
                 return;
             }
-            const key = CREATE_KEY_FN$7(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
+            const key = CREATE_KEY_FN$8(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
             this.getSource.clear(key);
         };
     }
@@ -31633,7 +31882,7 @@ const LISTEN_TIMEOUT = 120000;
  * @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);
@@ -31676,7 +31925,7 @@ class TimeMetaService {
          * Each subject holds the latest createdAt timestamp emitted by the strategy iterator for that key.
          * Instances are cached until clear() is called.
          */
-        this.getSource = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, exchangeName, frameName, backtest), () => new functoolsKit.BehaviorSubject());
+        this.getSource = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$7(symbol, strategyName, exchangeName, frameName, backtest), () => new functoolsKit.BehaviorSubject());
         /**
          * Returns the current candle timestamp (in milliseconds) for the given symbol and context.
          *
@@ -31704,10 +31953,10 @@ class TimeMetaService {
             if (source.data) {
                 return source.data;
             }
-            console.warn(`TimeMetaService: No timestamp available for ${CREATE_KEY_FN$6(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}. Trying to fetch from strategy iterator as a fallback...`);
+            console.warn(`TimeMetaService: No timestamp available for ${CREATE_KEY_FN$7(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}. Trying to fetch from strategy iterator as a fallback...`);
             const timestamp = await functoolsKit.waitForNext(source, (data) => !!data, LISTEN_TIMEOUT);
             if (typeof timestamp === "symbol") {
-                throw new Error(`TimeMetaService: Timeout while waiting for timestamp for ${CREATE_KEY_FN$6(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}`);
+                throw new Error(`TimeMetaService: Timeout while waiting for timestamp for ${CREATE_KEY_FN$7(symbol, context.strategyName, context.exchangeName, context.frameName, backtest)}`);
             }
             return timestamp;
         };
@@ -31749,7 +31998,7 @@ class TimeMetaService {
                 this.getSource.clear();
                 return;
             }
-            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.getSource.clear(key);
         };
     }
@@ -31845,7 +32094,7 @@ class MaxDrawdownReportService {
 /**
  * Creates a unique memoization key for a symbol-strategy-exchange-frame-backtest combination.
  */
-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);
@@ -31969,7 +32218,7 @@ class ReportStorage {
 class MaxDrawdownMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$5(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage(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(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to `maxDrawdownSubject` to start receiving `MaxDrawdownContract`
          * events. Protected against multiple subscriptions via `singleshot`.
@@ -32048,7 +32297,7 @@ class MaxDrawdownMarkdownService {
         this.clear = async (payload) => {
             this.loggerService.log("maxDrawdownMarkdownService 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 {
@@ -35181,6 +35430,8 @@ const GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE_METHOD_NAME = "strateg
 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_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE_METHOD_NAME = "strategy.getMaxDrawdownDistancePnlPercentage";
+const GET_MAX_DRAWDOWN_DISTANCE_PNL_COST_METHOD_NAME = "strategy.getMaxDrawdownDistancePnlCost";
 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";
@@ -35196,7 +35447,7 @@ const HAS_NO_SCHEDULED_SIGNAL_METHOD_NAME = "strategy.hasNoScheduledSignal";
  *
  * @param symbol - Trading pair symbol
  * @param strategyName - Strategy name
- * @param cancelId - Optional cancellation ID for tracking user-initiated cancellations
+ * @param payload - Optional commit payload with id and note
  * @returns Promise that resolves when scheduled signal is cancelled
  *
  * @example
@@ -35204,13 +35455,13 @@ const HAS_NO_SCHEDULED_SIGNAL_METHOD_NAME = "strategy.hasNoScheduledSignal";
  * import { commitCancelScheduled } from "backtest-kit";
  *
  * // Cancel scheduled signal with custom ID
- * await commitCancelScheduled("BTCUSDT", "manual-cancel-001");
+ * await commitCancelScheduled("BTCUSDT", { id: "manual-cancel-001" });
  * ```
  */
-async function commitCancelScheduled(symbol, cancelId) {
+async function commitCancelScheduled(symbol, payload = {}) {
     backtest.loggerService.info(CANCEL_SCHEDULED_METHOD_NAME, {
         symbol,
-        cancelId,
+        payload,
     });
     if (!ExecutionContextService.hasContext()) {
         throw new Error("commitCancelScheduled requires an execution context");
@@ -35220,7 +35471,7 @@ async function commitCancelScheduled(symbol, cancelId) {
     }
     const { backtest: isBacktest } = backtest.executionContextService.context;
     const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
-    await backtest.strategyCoreService.cancelScheduled(isBacktest, symbol, { exchangeName, frameName, strategyName }, cancelId);
+    await backtest.strategyCoreService.cancelScheduled(isBacktest, symbol, { exchangeName, frameName, strategyName }, payload);
 }
 /**
  * Closes the pending signal without stopping the strategy.
@@ -35232,7 +35483,7 @@ async function commitCancelScheduled(symbol, cancelId) {
  * Automatically detects backtest/live mode from execution context.
  *
  * @param symbol - Trading pair symbol
- * @param closeId - Optional close ID for tracking user-initiated closes
+ * @param payload - Optional commit payload with id and note
  * @returns Promise that resolves when pending signal is closed
  *
  * @example
@@ -35240,13 +35491,13 @@ async function commitCancelScheduled(symbol, cancelId) {
  * import { commitClosePending } from "backtest-kit";
  *
  * // Close pending signal with custom ID
- * await commitClosePending("BTCUSDT", "manual-close-001");
+ * await commitClosePending("BTCUSDT", { id: "manual-close-001" });
  * ```
  */
-async function commitClosePending(symbol, closeId) {
+async function commitClosePending(symbol, payload = {}) {
     backtest.loggerService.info(CLOSE_PENDING_METHOD_NAME, {
         symbol,
-        closeId,
+        payload,
     });
     if (!ExecutionContextService.hasContext()) {
         throw new Error("commitClosePending requires an execution context");
@@ -35256,7 +35507,7 @@ async function commitClosePending(symbol, closeId) {
     }
     const { backtest: isBacktest } = backtest.executionContextService.context;
     const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
-    await backtest.strategyCoreService.closePending(isBacktest, symbol, { exchangeName, frameName, strategyName }, closeId);
+    await backtest.strategyCoreService.closePending(isBacktest, symbol, { exchangeName, frameName, strategyName }, payload);
 }
 /**
  * Executes partial close at profit level (moving toward TP).
@@ -35719,7 +35970,7 @@ async function commitBreakeven(symbol) {
  * Automatically detects backtest/live mode from execution context.
  *
  * @param symbol - Trading pair symbol
- * @param activateId - Optional activation ID for tracking user-initiated activations
+ * @param payload - Optional commit payload with id and note
  * @returns Promise that resolves when activation flag is set
  *
  * @example
@@ -35727,13 +35978,13 @@ async function commitBreakeven(symbol) {
  * import { commitActivateScheduled } from "backtest-kit";
  *
  * // Activate scheduled signal early with custom ID
- * await commitActivateScheduled("BTCUSDT", "manual-activate-001");
+ * await commitActivateScheduled("BTCUSDT", { id: "manual-activate-001" });
  * ```
  */
-async function commitActivateScheduled(symbol, activateId) {
+async function commitActivateScheduled(symbol, payload = {}) {
     backtest.loggerService.info(ACTIVATE_SCHEDULED_METHOD_NAME, {
         symbol,
-        activateId,
+        payload,
     });
     if (!ExecutionContextService.hasContext()) {
         throw new Error("commitActivateScheduled requires an execution context");
@@ -35743,7 +35994,7 @@ async function commitActivateScheduled(symbol, activateId) {
     }
     const { backtest: isBacktest } = backtest.executionContextService.context;
     const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
-    await backtest.strategyCoreService.activateScheduled(isBacktest, symbol, { exchangeName, frameName, strategyName }, activateId);
+    await backtest.strategyCoreService.activateScheduled(isBacktest, symbol, { exchangeName, frameName, strategyName }, payload);
 }
 /**
  * Adds a new DCA entry to the active pending signal.
@@ -36931,6 +37182,64 @@ async function getPositionHighestMaxDrawdownPnlCost(symbol) {
     const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
     return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlCost(isBacktest, symbol, { exchangeName, frameName, strategyName });
 }
+/**
+ * Returns the peak-to-trough PnL percentage distance between the position's highest profit and deepest drawdown.
+ *
+ * Computed as: max(0, peakPnlPercentage - fallPnlPercentage).
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to peak-to-trough PnL percentage distance (≥ 0) or null
+ *
+ * @example
+ * ```typescript
+ * import { getMaxDrawdownDistancePnlPercentage } from "backtest-kit";
+ *
+ * const dist = await getMaxDrawdownDistancePnlPercentage("BTCUSDT");
+ * // e.g. 3.5 (peak was +3.5% above trough)
+ * ```
+ */
+async function getMaxDrawdownDistancePnlPercentage(symbol) {
+    backtest.loggerService.info(GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getMaxDrawdownDistancePnlPercentage requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getMaxDrawdownDistancePnlPercentage requires a method context");
+    }
+    const { backtest: isBacktest } = backtest.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await backtest.strategyCoreService.getMaxDrawdownDistancePnlPercentage(isBacktest, symbol, { exchangeName, frameName, strategyName });
+}
+/**
+ * Returns the peak-to-trough PnL cost distance between the position's highest profit and deepest drawdown.
+ *
+ * Computed as: max(0, peakPnlCost - fallPnlCost).
+ * Returns null if no pending signal exists.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to peak-to-trough PnL cost distance (≥ 0) or null
+ *
+ * @example
+ * ```typescript
+ * import { getMaxDrawdownDistancePnlCost } from "backtest-kit";
+ *
+ * const dist = await getMaxDrawdownDistancePnlCost("BTCUSDT");
+ * // e.g. 7.2 (peak was $7.2 above trough)
+ * ```
+ */
+async function getMaxDrawdownDistancePnlCost(symbol) {
+    backtest.loggerService.info(GET_MAX_DRAWDOWN_DISTANCE_PNL_COST_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getMaxDrawdownDistancePnlCost requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getMaxDrawdownDistancePnlCost requires a method context");
+    }
+    const { backtest: isBacktest } = backtest.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await backtest.strategyCoreService.getMaxDrawdownDistancePnlCost(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.
@@ -38604,6 +38913,8 @@ const BACKTEST_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE =
 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_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE = "BacktestUtils.getMaxDrawdownDistancePnlPercentage";
+const BACKTEST_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST = "BacktestUtils.getMaxDrawdownDistancePnlCost";
 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";
@@ -39985,6 +40296,62 @@ class BacktestUtils {
             }
             return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlCost(true, symbol, context);
         };
+        /**
+         * Returns the peak-to-trough PnL percentage distance between the position's highest profit and deepest drawdown.
+         *
+         * Computed as: max(0, peakPnlPercentage - fallPnlPercentage).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns peak-to-trough PnL percentage distance (≥ 0) or null if no active position
+         */
+        this.getMaxDrawdownDistancePnlPercentage = async (symbol, context) => {
+            backtest.loggerService.info(BACKTEST_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getMaxDrawdownDistancePnlPercentage(true, symbol, context);
+        };
+        /**
+         * Returns the peak-to-trough PnL cost distance between the position's highest profit and deepest drawdown.
+         *
+         * Computed as: max(0, peakPnlCost - fallPnlCost).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @returns peak-to-trough PnL cost distance (≥ 0) or null if no active position
+         */
+        this.getMaxDrawdownDistancePnlCost = async (symbol, context) => {
+            backtest.loggerService.info(BACKTEST_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getMaxDrawdownDistancePnlCost(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.
@@ -40119,7 +40486,7 @@ class BacktestUtils {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name
          * @param context - Execution context with exchangeName and frameName
-         * @param cancelId - Optional cancellation ID for tracking user-initiated cancellations
+         * @param payload - Optional commit payload with id and note
          * @returns Promise that resolves when scheduled signal is cancelled
          *
          * @example
@@ -40129,14 +40496,14 @@ class BacktestUtils {
          *   exchangeName: "binance",
          *   frameName: "frame1",
          *   strategyName: "my-strategy"
-         * }, "manual-cancel-001");
+         * }, { id: "manual-cancel-001" });
          * ```
          */
-        this.commitCancelScheduled = async (symbol, context, cancelId) => {
+        this.commitCancelScheduled = async (symbol, context, payload = {}) => {
             backtest.loggerService.info(BACKTEST_METHOD_NAME_CANCEL_SCHEDULED, {
                 symbol,
                 context,
-                cancelId,
+                payload,
             });
             backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED);
             backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED);
@@ -40149,7 +40516,7 @@ class BacktestUtils {
                 actions &&
                     actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED));
             }
-            await backtest.strategyCoreService.cancelScheduled(true, symbol, context, cancelId);
+            await backtest.strategyCoreService.cancelScheduled(true, symbol, context, payload);
         };
         /**
          * Closes the pending signal without stopping the strategy.
@@ -40160,7 +40527,7 @@ class BacktestUtils {
          *
          * @param symbol - Trading pair symbol
          * @param context - Execution context with strategyName, exchangeName, and frameName
-         * @param closeId - Optional close ID for user-initiated closes
+         * @param payload - Optional commit payload with id and note
          * @returns Promise that resolves when pending signal is closed
          *
          * @example
@@ -40170,14 +40537,14 @@ class BacktestUtils {
          *   exchangeName: "binance",
          *   strategyName: "my-strategy",
          *   frameName: "1m"
-         * }, "manual-close-001");
+         * }, { id: "manual-close-001" });
          * ```
          */
-        this.commitClosePending = async (symbol, context, closeId) => {
+        this.commitClosePending = async (symbol, context, payload = {}) => {
             backtest.loggerService.info(BACKTEST_METHOD_NAME_CLOSE_PENDING, {
                 symbol,
                 context,
-                closeId,
+                payload,
             });
             backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CLOSE_PENDING);
             backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CLOSE_PENDING);
@@ -40190,7 +40557,7 @@ class BacktestUtils {
                 actions &&
                     actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_CLOSE_PENDING));
             }
-            await backtest.strategyCoreService.closePending(true, symbol, context, closeId);
+            await backtest.strategyCoreService.closePending(true, symbol, context, payload);
         };
         /**
          * Executes partial close at profit level (moving toward TP).
@@ -40826,7 +41193,7 @@ class BacktestUtils {
          *
          * @param symbol - Trading pair symbol
          * @param context - Execution context with strategyName, exchangeName, and frameName
-         * @param activateId - Optional activation ID for tracking user-initiated activations
+         * @param payload - Optional commit payload with id and note
          * @returns Promise that resolves when activation flag is set
          *
          * @example
@@ -40836,14 +41203,14 @@ class BacktestUtils {
          *   strategyName: "my-strategy",
          *   exchangeName: "binance",
          *   frameName: "1h"
-         * }, "manual-activate-001");
+         * }, { id: "manual-activate-001" });
          * ```
          */
-        this.commitActivateScheduled = async (symbol, context, activateId) => {
+        this.commitActivateScheduled = async (symbol, context, payload = {}) => {
             backtest.loggerService.info(BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED, {
                 symbol,
                 context,
-                activateId,
+                payload,
             });
             backtest.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED);
             backtest.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED);
@@ -40856,7 +41223,7 @@ class BacktestUtils {
                 actions &&
                     actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED));
             }
-            await backtest.strategyCoreService.activateScheduled(true, symbol, context, activateId);
+            await backtest.strategyCoreService.activateScheduled(true, symbol, context, payload);
         };
         /**
          * Adds a new DCA entry to the active pending signal.
@@ -41114,6 +41481,8 @@ const LIVE_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE = "Li
 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_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE = "LiveUtils.getMaxDrawdownDistancePnlPercentage";
+const LIVE_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST = "LiveUtils.getMaxDrawdownDistancePnlCost";
 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";
@@ -42638,6 +43007,70 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Returns the peak-to-trough PnL percentage distance between the position's highest profit and deepest drawdown.
+         *
+         * Computed as: max(0, peakPnlPercentage - fallPnlPercentage).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns peak-to-trough PnL percentage distance (≥ 0) or null if no active position
+         */
+        this.getMaxDrawdownDistancePnlPercentage = async (symbol, context) => {
+            backtest.loggerService.info(LIVE_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getMaxDrawdownDistancePnlPercentage(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
+        };
+        /**
+         * Returns the peak-to-trough PnL cost distance between the position's highest profit and deepest drawdown.
+         *
+         * Computed as: max(0, peakPnlCost - fallPnlCost).
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @returns peak-to-trough PnL cost distance (≥ 0) or null if no active position
+         */
+        this.getMaxDrawdownDistancePnlCost = async (symbol, context) => {
+            backtest.loggerService.info(LIVE_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST, {
+                symbol,
+                context,
+            });
+            backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST);
+                riskList &&
+                    riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST));
+                actions &&
+                    actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, LIVE_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getMaxDrawdownDistancePnlCost(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.
@@ -42779,7 +43212,7 @@ class LiveUtils {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name
          * @param context - Execution context with exchangeName and frameName
-         * @param cancelId - Optional cancellation ID for tracking user-initiated cancellations
+         * @param payload - Optional commit payload with id and note
          * @returns Promise that resolves when scheduled signal is cancelled
          *
          * @example
@@ -42789,14 +43222,14 @@ class LiveUtils {
          *   exchangeName: "binance",
          *   frameName: "",
          *   strategyName: "my-strategy"
-         * }, "manual-cancel-001");
+         * }, { id: "manual-cancel-001" });
          * ```
          */
-        this.commitCancelScheduled = async (symbol, context, cancelId) => {
+        this.commitCancelScheduled = async (symbol, context, payload = {}) => {
             backtest.loggerService.info(LIVE_METHOD_NAME_CANCEL_SCHEDULED, {
                 symbol,
                 context,
-                cancelId,
+                payload,
             });
             backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CANCEL_SCHEDULED);
             backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CANCEL_SCHEDULED);
@@ -42813,7 +43246,7 @@ class LiveUtils {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
-            }, cancelId);
+            }, payload);
         };
         /**
          * Closes the pending signal without stopping the strategy.
@@ -42824,7 +43257,7 @@ class LiveUtils {
          *
          * @param symbol - Trading pair symbol
          * @param context - Execution context with strategyName and exchangeName
-         * @param closeId - Optional close ID for user-initiated closes
+         * @param payload - Optional commit payload with id and note
          * @returns Promise that resolves when pending signal is closed
          *
          * @example
@@ -42833,14 +43266,14 @@ class LiveUtils {
          * await Live.commitClose("BTCUSDT", {
          *   exchangeName: "binance",
          *   strategyName: "my-strategy"
-         * }, "manual-close-001");
+         * }, { id: "manual-close-001" });
          * ```
          */
-        this.commitClosePending = async (symbol, context, closeId) => {
+        this.commitClosePending = async (symbol, context, payload = {}) => {
             backtest.loggerService.info(LIVE_METHOD_NAME_CLOSE_PENDING, {
                 symbol,
                 context,
-                closeId,
+                payload,
             });
             backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CLOSE_PENDING);
             backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CLOSE_PENDING);
@@ -42857,7 +43290,7 @@ class LiveUtils {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
-            }, closeId);
+            }, payload);
         };
         /**
          * Executes partial close at profit level (moving toward TP).
@@ -43651,7 +44084,7 @@ class LiveUtils {
          *
          * @param symbol - Trading pair symbol
          * @param context - Execution context with strategyName and exchangeName
-         * @param activateId - Optional activation ID for tracking user-initiated activations
+         * @param payload - Optional commit payload with id and note
          * @returns Promise that resolves when activation flag is set
          *
          * @example
@@ -43660,14 +44093,14 @@ class LiveUtils {
          * await Live.commitActivateScheduled("BTCUSDT", {
          *   strategyName: "my-strategy",
          *   exchangeName: "binance"
-         * }, "manual-activate-001");
+         * }, { id: "manual-activate-001" });
          * ```
          */
-        this.commitActivateScheduled = async (symbol, context, activateId) => {
+        this.commitActivateScheduled = async (symbol, context, payload = {}) => {
             backtest.loggerService.info(LIVE_METHOD_NAME_ACTIVATE_SCHEDULED, {
                 symbol,
                 context,
-                activateId,
+                payload,
             });
             backtest.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED);
             backtest.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED);
@@ -43684,7 +44117,7 @@ class LiveUtils {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
-            }, activateId);
+            }, payload);
         };
         /**
          * Adds a new DCA entry to the active pending signal.
@@ -44930,6 +45363,503 @@ async function listRiskSchema() {
     return await backtest.riskValidationService.list();
 }
 
+const RECENT_PERSIST_BACKTEST_METHOD_NAME_HANDLE_ACTIVE_PING = "RecentPersistBacktestUtils.handleActivePing";
+const RECENT_PERSIST_BACKTEST_METHOD_NAME_GET_LATEST_SIGNAL = "RecentPersistBacktestUtils.getLatestSignal";
+const RECENT_PERSIST_LIVE_METHOD_NAME_HANDLE_ACTIVE_PING = "RecentPersistLiveUtils.handleActivePing";
+const RECENT_PERSIST_LIVE_METHOD_NAME_GET_LATEST_SIGNAL = "RecentPersistLiveUtils.getLatestSignal";
+const RECENT_MEMORY_BACKTEST_METHOD_NAME_HANDLE_ACTIVE_PING = "RecentMemoryBacktestUtils.handleActivePing";
+const RECENT_MEMORY_BACKTEST_METHOD_NAME_GET_LATEST_SIGNAL = "RecentMemoryBacktestUtils.getLatestSignal";
+const RECENT_MEMORY_LIVE_METHOD_NAME_HANDLE_ACTIVE_PING = "RecentMemoryLiveUtils.handleActivePing";
+const RECENT_MEMORY_LIVE_METHOD_NAME_GET_LATEST_SIGNAL = "RecentMemoryLiveUtils.getLatestSignal";
+const RECENT_BACKTEST_ADAPTER_METHOD_NAME_HANDLE_ACTIVE_PING = "RecentBacktestAdapter.handleActivePing";
+const RECENT_BACKTEST_ADAPTER_METHOD_NAME_GET_LATEST_SIGNAL = "RecentBacktestAdapter.getLatestSignal";
+const RECENT_BACKTEST_ADAPTER_METHOD_NAME_USE_ADAPTER = "RecentBacktestAdapter.useRecentAdapter";
+const RECENT_BACKTEST_ADAPTER_METHOD_NAME_USE_PERSIST = "RecentBacktestAdapter.usePersist";
+const RECENT_BACKTEST_ADAPTER_METHOD_NAME_USE_MEMORY = "RecentBacktestAdapter.useMemory";
+const RECENT_BACKTEST_ADAPTER_METHOD_NAME_CLEAR = "RecentBacktestAdapter.clear";
+const RECENT_LIVE_ADAPTER_METHOD_NAME_HANDLE_ACTIVE_PING = "RecentLiveAdapter.handleActivePing";
+const RECENT_LIVE_ADAPTER_METHOD_NAME_GET_LATEST_SIGNAL = "RecentLiveAdapter.getLatestSignal";
+const RECENT_LIVE_ADAPTER_METHOD_NAME_USE_ADAPTER = "RecentLiveAdapter.useRecentAdapter";
+const RECENT_LIVE_ADAPTER_METHOD_NAME_USE_PERSIST = "RecentLiveAdapter.usePersist";
+const RECENT_LIVE_ADAPTER_METHOD_NAME_USE_MEMORY = "RecentLiveAdapter.useMemory";
+const RECENT_LIVE_ADAPTER_METHOD_NAME_CLEAR = "RecentLiveAdapter.clear";
+const RECENT_ADAPTER_METHOD_NAME_ENABLE = "RecentAdapter.enable";
+const RECENT_ADAPTER_METHOD_NAME_DISABLE = "RecentAdapter.disable";
+const RECENT_ADAPTER_METHOD_NAME_GET_LATEST_SIGNAL = "RecentAdapter.getLatestSignal";
+/**
+ * Builds a composite storage key from context parts.
+ * Includes backtest flag as the last segment to prevent live/backtest collisions.
+ * @param symbol - Trading pair symbol
+ * @param strategyName - Strategy identifier
+ * @param exchangeName - Exchange identifier
+ * @param frameName - Frame identifier
+ * @param backtest - Flag indicating if the context is backtest or live
+ * @returns Composite key string
+ */
+const CREATE_KEY_FN$5 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
+/**
+ * Persistent storage adapter for backtest recent signals.
+ *
+ * Features:
+ * - Persists the latest active signal per context to disk using PersistRecentAdapter
+ * - Handles active ping events only
+ *
+ * Use this adapter for backtest recent signal persistence across sessions.
+ */
+class RecentPersistBacktestUtils {
+    constructor() {
+        /**
+         * Handles active ping event.
+         * Persists the latest signal to disk via PersistRecentAdapter.
+         * @param event - Active ping contract with signal data and backtest flag
+         */
+        this.handleActivePing = async (event) => {
+            backtest.loggerService.info(RECENT_PERSIST_BACKTEST_METHOD_NAME_HANDLE_ACTIVE_PING, {
+                signalId: event.data.id,
+            });
+            await PersistRecentAdapter.writeRecentData(event.data, event.symbol, event.strategyName, event.exchangeName, event.data.frameName, event.backtest);
+        };
+        /**
+         * Retrieves the latest persisted signal for the given context.
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns The latest signal or null if not found
+         */
+        this.getLatestSignal = async (symbol, strategyName, exchangeName, frameName, backtest$1) => {
+            backtest.loggerService.info(RECENT_PERSIST_BACKTEST_METHOD_NAME_GET_LATEST_SIGNAL, {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest: backtest$1,
+            });
+            return await PersistRecentAdapter.readRecentData(symbol, strategyName, exchangeName, frameName, backtest$1);
+        };
+    }
+}
+/**
+ * In-memory storage adapter for backtest recent signals.
+ *
+ * Features:
+ * - Stores the latest active signal per context key in memory only
+ * - Fast read/write operations
+ * - Data is lost when application restarts
+ *
+ * Use this adapter for testing or when persistence is not required.
+ */
+class RecentMemoryBacktestUtils {
+    constructor() {
+        /** Map of composite context keys to the latest signal */
+        this._signals = new Map();
+        /**
+         * Handles active ping event.
+         * Stores the latest signal in memory under the composite context key.
+         * @param event - Active ping contract with signal data and backtest flag
+         */
+        this.handleActivePing = async (event) => {
+            backtest.loggerService.info(RECENT_MEMORY_BACKTEST_METHOD_NAME_HANDLE_ACTIVE_PING, {
+                signalId: event.data.id,
+            });
+            const key = CREATE_KEY_FN$5(event.symbol, event.strategyName, event.exchangeName, event.data.frameName, event.backtest);
+            this._signals.set(key, event.data);
+        };
+        /**
+         * Retrieves the latest in-memory signal for the given context.
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns The latest signal or null if not found
+         */
+        this.getLatestSignal = async (symbol, strategyName, exchangeName, frameName, backtest$1) => {
+            const key = CREATE_KEY_FN$5(symbol, strategyName, exchangeName, frameName, backtest$1);
+            backtest.loggerService.info(RECENT_MEMORY_BACKTEST_METHOD_NAME_GET_LATEST_SIGNAL, { key });
+            return this._signals.get(key) ?? null;
+        };
+    }
+}
+/**
+ * Persistent storage adapter for live recent signals.
+ *
+ * Features:
+ * - Persists the latest active signal per context to disk using PersistRecentAdapter
+ * - Handles active ping events only
+ *
+ * Use this adapter (default) for live recent signal persistence across sessions.
+ */
+class RecentPersistLiveUtils {
+    constructor() {
+        /**
+         * Handles active ping event.
+         * Persists the latest signal to disk via PersistRecentAdapter.
+         * @param event - Active ping contract with signal data and backtest flag
+         */
+        this.handleActivePing = async (event) => {
+            backtest.loggerService.info(RECENT_PERSIST_LIVE_METHOD_NAME_HANDLE_ACTIVE_PING, {
+                signalId: event.data.id,
+            });
+            await PersistRecentAdapter.writeRecentData(event.data, event.symbol, event.strategyName, event.exchangeName, event.data.frameName, event.backtest);
+        };
+        /**
+         * Retrieves the latest persisted signal for the given context.
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns The latest signal or null if not found
+         */
+        this.getLatestSignal = async (symbol, strategyName, exchangeName, frameName, backtest$1) => {
+            backtest.loggerService.info(RECENT_PERSIST_LIVE_METHOD_NAME_GET_LATEST_SIGNAL, {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest: backtest$1,
+            });
+            return await PersistRecentAdapter.readRecentData(symbol, strategyName, exchangeName, frameName, backtest$1);
+        };
+    }
+}
+/**
+ * In-memory storage adapter for live recent signals.
+ *
+ * Features:
+ * - Stores the latest active signal per context key in memory only
+ * - Fast read/write operations
+ * - Data is lost when application restarts
+ *
+ * Use this adapter for testing or when persistence is not required.
+ */
+class RecentMemoryLiveUtils {
+    constructor() {
+        /** Map of composite context keys to the latest signal */
+        this._signals = new Map();
+        /**
+         * Handles active ping event.
+         * Stores the latest signal in memory under the composite context key.
+         * @param event - Active ping contract with signal data and backtest flag
+         */
+        this.handleActivePing = async (event) => {
+            backtest.loggerService.info(RECENT_MEMORY_LIVE_METHOD_NAME_HANDLE_ACTIVE_PING, {
+                signalId: event.data.id,
+            });
+            const key = CREATE_KEY_FN$5(event.symbol, event.strategyName, event.exchangeName, event.data.frameName, event.backtest);
+            this._signals.set(key, event.data);
+        };
+        /**
+         * Retrieves the latest in-memory signal for the given context.
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns The latest signal or null if not found
+         */
+        this.getLatestSignal = async (symbol, strategyName, exchangeName, frameName, backtest$1) => {
+            const key = CREATE_KEY_FN$5(symbol, strategyName, exchangeName, frameName, backtest$1);
+            backtest.loggerService.info(RECENT_MEMORY_LIVE_METHOD_NAME_GET_LATEST_SIGNAL, { key });
+            return this._signals.get(key) ?? null;
+        };
+    }
+}
+/**
+ * Backtest recent signal adapter with pluggable storage backend.
+ *
+ * Features:
+ * - Adapter pattern for swappable storage implementations
+ * - Default adapter: RecentMemoryBacktestUtils (in-memory storage)
+ * - Alternative adapter: RecentPersistBacktestUtils
+ * - Convenience methods: usePersist(), useMemory()
+ */
+class RecentBacktestAdapter {
+    constructor() {
+        /** Internal storage utils instance */
+        this._recentBacktestUtils = new RecentMemoryBacktestUtils();
+        /**
+         * Handles active ping event.
+         * Proxies call to the underlying storage adapter.
+         * @param event - Active ping contract with signal data
+         */
+        this.handleActivePing = async (event) => {
+            backtest.loggerService.info(RECENT_BACKTEST_ADAPTER_METHOD_NAME_HANDLE_ACTIVE_PING, {
+                signalId: event.data.id,
+            });
+            return await this._recentBacktestUtils.handleActivePing(event);
+        };
+        /**
+         * Retrieves the latest signal for the given context.
+         * Proxies call to the underlying storage adapter.
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns The latest signal or null if not found
+         */
+        this.getLatestSignal = async (symbol, strategyName, exchangeName, frameName, backtest$1) => {
+            backtest.loggerService.info(RECENT_BACKTEST_ADAPTER_METHOD_NAME_GET_LATEST_SIGNAL, {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest: backtest$1,
+            });
+            return await this._recentBacktestUtils.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1);
+        };
+        /**
+         * Sets the storage adapter constructor.
+         * All future storage operations will use this adapter.
+         * @param Ctor - Constructor for recent adapter
+         */
+        this.useRecentAdapter = (Ctor) => {
+            backtest.loggerService.info(RECENT_BACKTEST_ADAPTER_METHOD_NAME_USE_ADAPTER);
+            this._recentBacktestUtils = Reflect.construct(Ctor, []);
+        };
+        /**
+         * Switches to persistent storage adapter.
+         * Signals will be persisted to disk.
+         */
+        this.usePersist = () => {
+            backtest.loggerService.info(RECENT_BACKTEST_ADAPTER_METHOD_NAME_USE_PERSIST);
+            this._recentBacktestUtils = new RecentPersistBacktestUtils();
+        };
+        /**
+         * Switches to in-memory storage adapter (default).
+         * Signals will be stored in memory only.
+         */
+        this.useMemory = () => {
+            backtest.loggerService.info(RECENT_BACKTEST_ADAPTER_METHOD_NAME_USE_MEMORY);
+            this._recentBacktestUtils = new RecentMemoryBacktestUtils();
+        };
+        /**
+         * Clears the cached utils instance by resetting to the default in-memory adapter.
+         */
+        this.clear = () => {
+            backtest.loggerService.info(RECENT_BACKTEST_ADAPTER_METHOD_NAME_CLEAR);
+            this._recentBacktestUtils = new RecentMemoryBacktestUtils();
+        };
+    }
+}
+/**
+ * Live recent signal adapter with pluggable storage backend.
+ *
+ * Features:
+ * - Adapter pattern for swappable storage implementations
+ * - Default adapter: RecentPersistLiveUtils (persistent storage)
+ * - Alternative adapter: RecentMemoryLiveUtils
+ * - Convenience methods: usePersist(), useMemory()
+ */
+class RecentLiveAdapter {
+    constructor() {
+        /** Internal storage utils instance */
+        this._recentLiveUtils = new RecentPersistLiveUtils();
+        /**
+         * Handles active ping event.
+         * Proxies call to the underlying storage adapter.
+         * @param event - Active ping contract with signal data
+         */
+        this.handleActivePing = async (event) => {
+            backtest.loggerService.info(RECENT_LIVE_ADAPTER_METHOD_NAME_HANDLE_ACTIVE_PING, {
+                signalId: event.data.id,
+            });
+            return await this._recentLiveUtils.handleActivePing(event);
+        };
+        /**
+         * Retrieves the latest signal for the given context.
+         * Proxies call to the underlying storage adapter.
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @param frameName - Frame identifier
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns The latest signal or null if not found
+         */
+        this.getLatestSignal = async (symbol, strategyName, exchangeName, frameName, backtest$1) => {
+            backtest.loggerService.info(RECENT_LIVE_ADAPTER_METHOD_NAME_GET_LATEST_SIGNAL, {
+                symbol,
+                strategyName,
+                exchangeName,
+                frameName,
+                backtest: backtest$1,
+            });
+            return await this._recentLiveUtils.getLatestSignal(symbol, strategyName, exchangeName, frameName, backtest$1);
+        };
+        /**
+         * Sets the storage adapter constructor.
+         * All future storage operations will use this adapter.
+         * @param Ctor - Constructor for recent adapter
+         */
+        this.useRecentAdapter = (Ctor) => {
+            backtest.loggerService.info(RECENT_LIVE_ADAPTER_METHOD_NAME_USE_ADAPTER);
+            this._recentLiveUtils = Reflect.construct(Ctor, []);
+        };
+        /**
+         * Switches to persistent storage adapter (default).
+         * Signals will be persisted to disk.
+         */
+        this.usePersist = () => {
+            backtest.loggerService.info(RECENT_LIVE_ADAPTER_METHOD_NAME_USE_PERSIST);
+            this._recentLiveUtils = new RecentPersistLiveUtils();
+        };
+        /**
+         * Switches to in-memory storage adapter.
+         * Signals will be stored in memory only.
+         */
+        this.useMemory = () => {
+            backtest.loggerService.info(RECENT_LIVE_ADAPTER_METHOD_NAME_USE_MEMORY);
+            this._recentLiveUtils = new RecentMemoryLiveUtils();
+        };
+        /**
+         * Clears the cached utils instance by resetting to the default persistent adapter.
+         */
+        this.clear = () => {
+            backtest.loggerService.info(RECENT_LIVE_ADAPTER_METHOD_NAME_CLEAR);
+            this._recentLiveUtils = new RecentPersistLiveUtils();
+        };
+    }
+}
+/**
+ * Main recent signal adapter that manages both backtest and live recent signal storage.
+ *
+ * Features:
+ * - Subscribes to activePingSubject for automatic storage updates
+ * - Provides unified access to the latest signal for any context
+ * - Singleshot enable pattern prevents duplicate subscriptions
+ * - Cleanup function for proper unsubscription
+ */
+class RecentAdapter {
+    constructor() {
+        /**
+         * Enables recent signal storage by subscribing to activePingSubject.
+         * Uses singleshot to ensure one-time subscription.
+         *
+         * @returns Cleanup function that unsubscribes from all emitters
+         */
+        this.enable = functoolsKit.singleshot(() => {
+            backtest.loggerService.info(RECENT_ADAPTER_METHOD_NAME_ENABLE);
+            let unBacktest;
+            let unLive;
+            {
+                const unBacktestPingActive = activePingSubject
+                    .filter(({ backtest }) => backtest)
+                    .connect((event) => RecentBacktest.handleActivePing(event));
+                unBacktest = functoolsKit.compose(() => unBacktestPingActive());
+            }
+            {
+                const unLivePingActive = activePingSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect((event) => RecentLive.handleActivePing(event));
+                unLive = functoolsKit.compose(() => unLivePingActive());
+            }
+            const unEnable = () => this.enable.clear();
+            return functoolsKit.compose(() => unBacktest(), () => unLive(), () => unEnable());
+        });
+        /**
+         * Disables recent signal storage by unsubscribing from all emitters.
+         * Safe to call multiple times.
+         */
+        this.disable = () => {
+            backtest.loggerService.info(RECENT_ADAPTER_METHOD_NAME_DISABLE);
+            if (this.enable.hasValue()) {
+                const lastSubscription = this.enable();
+                lastSubscription();
+            }
+        };
+        /**
+         * Retrieves the latest active signal for the given symbol and context.
+         * Searches backtest storage first, then live storage.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @param backtest - Flag indicating if the context is backtest or live
+         * @returns The latest signal or null if not found
+         * @throws Error if RecentAdapter is not enabled
+         */
+        this.getLatestSignal = async (symbol, context) => {
+            backtest.loggerService.info(RECENT_ADAPTER_METHOD_NAME_GET_LATEST_SIGNAL, {
+                symbol,
+                context,
+            });
+            if (!this.enable.hasValue()) {
+                throw new Error("RecentAdapter is not enabled. Call enable() first.");
+            }
+            let result = null;
+            if (result = await RecentBacktest.getLatestSignal(symbol, context.strategyName, context.exchangeName, context.frameName, true)) {
+                return result;
+            }
+            if (result = await RecentLive.getLatestSignal(symbol, context.strategyName, context.exchangeName, context.frameName, false)) {
+                return result;
+            }
+            return null;
+        };
+    }
+}
+/**
+ * Global singleton instance of RecentAdapter.
+ * Provides unified recent signal management for backtest and live trading.
+ */
+const Recent = new RecentAdapter();
+/**
+ * Global singleton instance of RecentLiveAdapter.
+ * Provides live trading recent signal storage with pluggable backends.
+ */
+const RecentLive = new RecentLiveAdapter();
+/**
+ * Global singleton instance of RecentBacktestAdapter.
+ * Provides backtest recent signal storage with pluggable backends.
+ */
+const RecentBacktest = new RecentBacktestAdapter();
+
+const GET_LATEST_SIGNAL_METHOD_NAME = "signal.getLatestSignal";
+/**
+ * Returns the latest signal (pending or closed) for the current strategy context.
+ *
+ * Does not distinguish between active and closed signals — returns whichever
+ * was recorded last. Useful for cooldown logic: e.g. skip opening a new position
+ * for 4 hours after a stop-loss by checking the timestamp of the latest signal
+ * regardless of its outcome.
+ *
+ * Searches backtest storage first, then live storage.
+ * Returns null if no signal exists at all.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @returns Promise resolving to the latest signal or null
+ *
+ * @example
+ * ```typescript
+ * import { getLatestSignal } from "backtest-kit";
+ *
+ * const latest = await getLatestSignal("BTCUSDT");
+ * if (latest && Date.now() - latest.closedAt < 4 * 60 * 60 * 1000) {
+ *   return; // cooldown after SL — skip new signal for 4 hours
+ * }
+ * ```
+ */
+async function getLatestSignal(symbol) {
+    backtest.loggerService.info(GET_LATEST_SIGNAL_METHOD_NAME, { symbol });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getLatestSignal requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getLatestSignal requires a method context");
+    }
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return await Recent.getLatestSignal(symbol, { exchangeName, frameName, strategyName });
+}
+
 const DEFAULT_BM25_K1 = 1.5;
 const DEFAULT_BM25_B = 0.75;
 const DEFAULT_BM25_SCORE = 0.5;
@@ -48180,6 +49110,67 @@ class LogAdapter {
  */
 const Log = new LogAdapter();
 
+const METHOD_NAME_CREATE_SNAPSHOT = "SessionUtils.createSnapshot";
+/** List of all global subjects whose listeners should be snapshotted for session isolation */
+const SUBJECT_ISOLATION_LIST = [
+    activePingSubject,
+    backtestScheduleOpenSubject,
+    breakevenSubject,
+    doneBacktestSubject,
+    doneLiveSubject,
+    errorEmitter,
+    exitEmitter,
+    highestProfitSubject,
+    maxDrawdownSubject,
+    partialLossSubject,
+    partialProfitSubject,
+    performanceEmitter,
+    progressBacktestEmitter,
+    riskSubject,
+    schedulePingSubject,
+    shutdownEmitter,
+    signalBacktestEmitter,
+    signalEmitter,
+    signalLiveEmitter,
+    strategyCommitSubject,
+    syncSubject,
+    validationSubject,
+];
+/**
+ * Creates a snapshot function for a given subject by clearing its internal
+ * events map and returning a restore function that can put the original listeners back.
+ * @param subject The subject to snapshot
+ * @returns A function that restores the subject's original listeners when called
+ */
+const CREATE_SUBJECT_SNAPSHOT_FN = (subject) => {
+    const emitter = subject["_emitter"];
+    const events = emitter["_events"];
+    emitter["_events"] = {};
+    return () => {
+        emitter["_events"] = events;
+    };
+};
+/**
+ * Manages isolation of global event-bus state between backtest sessions.
+ * Allows temporarily detaching all subject subscriptions so that one session
+ * does not interfere with another, then restoring them afterwards.
+ */
+class SessionUtils {
+    constructor() {
+        /**
+         * Snapshots the current listener state of every global subject by replacing
+         * their internal `_events` map with an empty object.
+         * @returns A restore function that, when called, puts all original listeners back.
+         */
+        this.createSnapshot = () => {
+            backtest.loggerService.log(METHOD_NAME_CREATE_SNAPSHOT);
+            const snapshotList = SUBJECT_ISOLATION_LIST.map(CREATE_SUBJECT_SNAPSHOT_FN);
+            return functoolsKit.compose(...snapshotList);
+        };
+    }
+}
+const Session = new SessionUtils();
+
 const SCHEDULE_METHOD_NAME_GET_DATA = "ScheduleUtils.getData";
 const SCHEDULE_METHOD_NAME_GET_REPORT = "ScheduleUtils.getReport";
 const SCHEDULE_METHOD_NAME_DUMP = "ScheduleUtils.dump";
@@ -49755,6 +50746,741 @@ class MaxDrawdownUtils {
  */
 const MaxDrawdown = new MaxDrawdownUtils();
 
+const REFLECT_METHOD_NAME_GET_POSITION_PNL_PERCENT = "ReflectUtils.getPositionPnlPercent";
+const REFLECT_METHOD_NAME_GET_POSITION_PNL_COST = "ReflectUtils.getPositionPnlCost";
+const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE = "ReflectUtils.getPositionHighestProfitPrice";
+const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP = "ReflectUtils.getPositionHighestProfitTimestamp";
+const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE = "ReflectUtils.getPositionHighestPnlPercentage";
+const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST = "ReflectUtils.getPositionHighestPnlCost";
+const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN = "ReflectUtils.getPositionHighestProfitBreakeven";
+const REFLECT_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES = "ReflectUtils.getPositionDrawdownMinutes";
+const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES = "ReflectUtils.getPositionHighestProfitMinutes";
+const REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES = "ReflectUtils.getPositionMaxDrawdownMinutes";
+const REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE = "ReflectUtils.getPositionMaxDrawdownPrice";
+const REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP = "ReflectUtils.getPositionMaxDrawdownTimestamp";
+const REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE = "ReflectUtils.getPositionMaxDrawdownPnlPercentage";
+const REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST = "ReflectUtils.getPositionMaxDrawdownPnlCost";
+const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE = "ReflectUtils.getPositionHighestProfitDistancePnlPercentage";
+const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST = "ReflectUtils.getPositionHighestProfitDistancePnlCost";
+const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE = "ReflectUtils.getPositionHighestMaxDrawdownPnlPercentage";
+const REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST = "ReflectUtils.getPositionHighestMaxDrawdownPnlCost";
+const REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE = "ReflectUtils.getMaxDrawdownDistancePnlPercentage";
+const REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST = "ReflectUtils.getMaxDrawdownDistancePnlCost";
+/**
+ * Utility class for real-time position reflection: PNL, peak profit, and drawdown queries.
+ *
+ * Provides unified access to strategyCoreService position state methods with logging
+ * and full validation (strategy, exchange, frame, risk, actions).
+ * Works for both live and backtest modes via the `backtest` parameter.
+ * Exported as singleton instance for convenient usage.
+ *
+ * @example
+ * ```typescript
+ * import { Reflect } from "backtest-kit";
+ *
+ * // Get current unrealized PNL percentage
+ * const pnl = await Reflect.getPositionPnlPercent(
+ *   "BTCUSDT",
+ *   45000,
+ *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+ * );
+ * console.log(`PNL: ${pnl}%`);
+ *
+ * // Get peak profit reached
+ * const peakPnl = await Reflect.getPositionHighestPnlPercentage(
+ *   "BTCUSDT",
+ *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+ * );
+ * console.log(`Peak PNL: ${peakPnl}%`);
+ * ```
+ */
+class ReflectUtils {
+    constructor() {
+        /**
+         * Returns the unrealized PNL percentage for the current pending signal at currentPrice.
+         *
+         * Accounts for partial closes, DCA entries, slippage and fees.
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to PNL percentage or null
+         *
+         * @example
+         * ```typescript
+         * const pnl = await Reflect.getPositionPnlPercent(
+         *   "BTCUSDT",
+         *   45000,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`PNL: ${pnl}%`);
+         * ```
+         */
+        this.getPositionPnlPercent = async (symbol, currentPrice, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_PNL_PERCENT, { symbol, currentPrice, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_PNL_PERCENT);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_PNL_PERCENT);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_PNL_PERCENT);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_PNL_PERCENT);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_PNL_PERCENT));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_PNL_PERCENT));
+            }
+            return await backtest.strategyCoreService.getPositionPnlPercent(backtest$1, symbol, currentPrice, context);
+        };
+        /**
+         * Returns the unrealized PNL in dollars for the current pending signal at currentPrice.
+         *
+         * Calculated as: pnlPercentage / 100 × totalInvestedCost.
+         * Accounts for partial closes, DCA entries, slippage and fees.
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param currentPrice - Current market price
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to PNL in dollars or null
+         *
+         * @example
+         * ```typescript
+         * const pnlCost = await Reflect.getPositionPnlCost(
+         *   "BTCUSDT",
+         *   45000,
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`PNL: $${pnlCost}`);
+         * ```
+         */
+        this.getPositionPnlCost = async (symbol, currentPrice, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_PNL_COST, { symbol, currentPrice, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_PNL_COST);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_PNL_COST);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_PNL_COST));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getPositionPnlCost(backtest$1, symbol, currentPrice, 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
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to price or null
+         *
+         * @example
+         * ```typescript
+         * const peakPrice = await Reflect.getPositionHighestProfitPrice(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Peak price: ${peakPrice}`);
+         * ```
+         */
+        this.getPositionHighestProfitPrice = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_PRICE));
+            }
+            return await backtest.strategyCoreService.getPositionHighestProfitPrice(backtest$1, 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
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to timestamp in milliseconds or null
+         *
+         * @example
+         * ```typescript
+         * const ts = await Reflect.getPositionHighestProfitTimestamp(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Peak at: ${new Date(ts).toISOString()}`);
+         * ```
+         */
+        this.getPositionHighestProfitTimestamp = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_TIMESTAMP));
+            }
+            return await backtest.strategyCoreService.getPositionHighestProfitTimestamp(backtest$1, 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
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to PnL percentage or null
+         *
+         * @example
+         * ```typescript
+         * const peakPnl = await Reflect.getPositionHighestPnlPercentage(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Peak PNL: ${peakPnl}%`);
+         * ```
+         */
+        this.getPositionHighestPnlPercentage = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getPositionHighestPnlPercentage(backtest$1, 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
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to PnL cost in quote currency or null
+         *
+         * @example
+         * ```typescript
+         * const peakCost = await Reflect.getPositionHighestPnlCost(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Peak PNL: $${peakCost}`);
+         * ```
+         */
+        this.getPositionHighestPnlCost = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getPositionHighestPnlCost(backtest$1, symbol, context);
+        };
+        /**
+         * Returns whether breakeven was mathematically reachable at the highest profit price.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to true if breakeven was reachable at peak, false otherwise, or null
+         *
+         * @example
+         * ```typescript
+         * const wasReachable = await Reflect.getPositionHighestProfitBreakeven(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Breakeven reachable at peak: ${wasReachable}`);
+         * ```
+         */
+        this.getPositionHighestProfitBreakeven = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_BREAKEVEN));
+            }
+            return await backtest.strategyCoreService.getPositionHighestProfitBreakeven(backtest$1, symbol, context);
+        };
+        /**
+         * Returns the number of minutes elapsed since the highest profit price was recorded.
+         *
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to minutes since highest profit price was recorded, or null
+         *
+         * @example
+         * ```typescript
+         * const minutes = await Reflect.getPositionDrawdownMinutes(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Pulling back from peak for ${minutes} minutes`);
+         * ```
+         */
+        this.getPositionDrawdownMinutes = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_DRAWDOWN_MINUTES));
+            }
+            return await backtest.strategyCoreService.getPositionDrawdownMinutes(backtest$1, symbol, context);
+        };
+        /**
+         * Returns the number of minutes elapsed since the highest profit price was recorded.
+         *
+         * Alias for getPositionDrawdownMinutes — measures how long the position has been
+         * pulling back from its peak profit level.
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to minutes since last profit peak or null
+         *
+         * @example
+         * ```typescript
+         * const minutes = await Reflect.getPositionHighestProfitMinutes(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Pulling back from peak for ${minutes} minutes`);
+         * ```
+         */
+        this.getPositionHighestProfitMinutes = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_MINUTES));
+            }
+            return await backtest.strategyCoreService.getPositionHighestProfitMinutes(backtest$1, symbol, context);
+        };
+        /**
+         * Returns the number of minutes elapsed since the worst loss price was recorded.
+         *
+         * Measures how long ago the deepest drawdown point occurred.
+         * Zero when called at the exact moment the trough was set.
+         * Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to minutes since last drawdown trough or null
+         *
+         * @example
+         * ```typescript
+         * const minutes = await Reflect.getPositionMaxDrawdownMinutes(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Drawdown trough was ${minutes} minutes ago`);
+         * ```
+         */
+        this.getPositionMaxDrawdownMinutes = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_MINUTES));
+            }
+            return await backtest.strategyCoreService.getPositionMaxDrawdownMinutes(backtest$1, symbol, context);
+        };
+        /**
+         * Returns the worst price reached in the loss 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
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to price or null
+         *
+         * @example
+         * ```typescript
+         * const troughPrice = await Reflect.getPositionMaxDrawdownPrice(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Worst price: ${troughPrice}`);
+         * ```
+         */
+        this.getPositionMaxDrawdownPrice = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PRICE));
+            }
+            return await backtest.strategyCoreService.getPositionMaxDrawdownPrice(backtest$1, symbol, context);
+        };
+        /**
+         * Returns the timestamp when the worst loss 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
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to timestamp in milliseconds or null
+         *
+         * @example
+         * ```typescript
+         * const ts = await Reflect.getPositionMaxDrawdownTimestamp(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Worst drawdown at: ${new Date(ts).toISOString()}`);
+         * ```
+         */
+        this.getPositionMaxDrawdownTimestamp = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_TIMESTAMP));
+            }
+            return await backtest.strategyCoreService.getPositionMaxDrawdownTimestamp(backtest$1, symbol, context);
+        };
+        /**
+         * Returns the PnL percentage at the moment the worst loss 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
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to PnL percentage or null
+         *
+         * @example
+         * ```typescript
+         * const worstPnl = await Reflect.getPositionMaxDrawdownPnlPercentage(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Worst PNL: ${worstPnl}%`);
+         * ```
+         */
+        this.getPositionMaxDrawdownPnlPercentage = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getPositionMaxDrawdownPnlPercentage(backtest$1, symbol, context);
+        };
+        /**
+         * Returns the PnL cost (in quote currency) at the moment the worst loss 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
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to PnL cost in quote currency or null
+         *
+         * @example
+         * ```typescript
+         * const worstCost = await Reflect.getPositionMaxDrawdownPnlCost(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Worst PNL: $${worstCost}`);
+         * ```
+         */
+        this.getPositionMaxDrawdownPnlCost = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_MAX_DRAWDOWN_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getPositionMaxDrawdownPnlCost(backtest$1, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL percentage between the current price and the highest profit peak.
+         *
+         * Result is ≥ 0. Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to drawdown distance in PnL% (≥ 0) or null
+         *
+         * @example
+         * ```typescript
+         * const distance = await Reflect.getPositionHighestProfitDistancePnlPercentage(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Dropped ${distance}% from peak`);
+         * ```
+         */
+        this.getPositionHighestProfitDistancePnlPercentage = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getPositionHighestProfitDistancePnlPercentage(backtest$1, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the highest profit peak.
+         *
+         * Result is ≥ 0. Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to drawdown distance in PnL cost (≥ 0) or null
+         *
+         * @example
+         * ```typescript
+         * const distance = await Reflect.getPositionHighestProfitDistancePnlCost(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Dropped $${distance} from peak`);
+         * ```
+         */
+        this.getPositionHighestProfitDistancePnlCost = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_PROFIT_DISTANCE_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getPositionHighestProfitDistancePnlCost(backtest$1, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL percentage between the current price and the worst drawdown trough.
+         *
+         * Result is ≥ 0. Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to recovery distance from worst drawdown trough in PnL% (≥ 0) or null
+         *
+         * @example
+         * ```typescript
+         * const distance = await Reflect.getPositionHighestMaxDrawdownPnlPercentage(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`${distance}% above worst trough`);
+         * ```
+         */
+        this.getPositionHighestMaxDrawdownPnlPercentage = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlPercentage(backtest$1, symbol, context);
+        };
+        /**
+         * Returns the distance in PnL cost between the current price and the worst drawdown trough.
+         *
+         * Result is ≥ 0. Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to recovery distance from worst drawdown trough in PnL cost (≥ 0) or null
+         *
+         * @example
+         * ```typescript
+         * const distance = await Reflect.getPositionHighestMaxDrawdownPnlCost(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`$${distance} above worst trough`);
+         * ```
+         */
+        this.getPositionHighestMaxDrawdownPnlCost = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_POSITION_HIGHEST_MAX_DRAWDOWN_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getPositionHighestMaxDrawdownPnlCost(backtest$1, symbol, context);
+        };
+        /**
+         * Returns the peak-to-trough PnL percentage distance between the position's highest profit and deepest drawdown.
+         *
+         * Result is ≥ 0. Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to peak-to-trough PnL percentage distance (≥ 0) or null
+         *
+         * @example
+         * ```typescript
+         * const distance = await Reflect.getMaxDrawdownDistancePnlPercentage(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Peak-to-trough: ${distance}%`);
+         * ```
+         */
+        this.getMaxDrawdownDistancePnlPercentage = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_PERCENTAGE));
+            }
+            return await backtest.strategyCoreService.getMaxDrawdownDistancePnlPercentage(backtest$1, symbol, context);
+        };
+        /**
+         * Returns the peak-to-trough PnL cost distance between the position's highest profit and deepest drawdown.
+         *
+         * Result is ≥ 0. Returns null if no pending signal exists.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
+         * @returns Promise resolving to peak-to-trough PnL cost distance (≥ 0) or null
+         *
+         * @example
+         * ```typescript
+         * const distance = await Reflect.getMaxDrawdownDistancePnlCost(
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+         * );
+         * console.log(`Peak-to-trough: $${distance}`);
+         * ```
+         */
+        this.getMaxDrawdownDistancePnlCost = async (symbol, context, backtest$1 = false) => {
+            backtest.loggerService.info(REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST, { symbol, context });
+            backtest.strategyValidationService.validate(context.strategyName, REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST);
+            backtest.exchangeValidationService.validate(context.exchangeName, REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST);
+            context.frameName && backtest.frameValidationService.validate(context.frameName, REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST);
+            {
+                const { riskName, riskList, actions } = backtest.strategySchemaService.get(context.strategyName);
+                riskName && backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST);
+                riskList && riskList.forEach((riskName) => backtest.riskValidationService.validate(riskName, REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST));
+                actions && actions.forEach((actionName) => backtest.actionValidationService.validate(actionName, REFLECT_METHOD_NAME_GET_MAX_DRAWDOWN_DISTANCE_PNL_COST));
+            }
+            return await backtest.strategyCoreService.getMaxDrawdownDistancePnlCost(backtest$1, symbol, context);
+        };
+    }
+}
+/**
+ * Singleton instance of ReflectUtils for convenient position state queries.
+ *
+ * @example
+ * ```typescript
+ * import { Reflect } from "backtest-kit";
+ *
+ * // Real-time PNL
+ * const pnl = await Reflect.getPositionPnlPercent(
+ *   "BTCUSDT",
+ *   45000,
+ *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+ * );
+ * console.log(`PNL: ${pnl}%`);
+ *
+ * // Peak profit
+ * const peakPnl = await Reflect.getPositionHighestPnlPercentage(
+ *   "BTCUSDT",
+ *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+ * );
+ * console.log(`Peak PNL: ${peakPnl}%`);
+ *
+ * // Drawdown from peak
+ * const drawdown = await Reflect.getPositionHighestProfitDistancePnlPercentage(
+ *   "BTCUSDT",
+ *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "frame1" }
+ * );
+ * console.log(`Dropped ${drawdown}% from peak`);
+ * ```
+ */
+const Reflect$1 = new ReflectUtils();
+
 /**
  * Utility class containing predefined trading constants for take-profit and stop-loss levels.
  *
@@ -53682,12 +55408,15 @@ const CACHE_METHOD_NAME_RUN = "CacheFnInstance.run";
 const CACHE_METHOD_NAME_FN = "CacheUtils.fn";
 const CACHE_METHOD_NAME_FN_CLEAR = "CacheUtils.fn.clear";
 const CACHE_METHOD_NAME_FN_GC = "CacheUtils.fn.gc";
+const CACHE_METHOD_NAME_FN_HAS_VALUE = "CacheUtils.fn.hasValue";
 const CACHE_METHOD_NAME_FILE = "CacheUtils.file";
 const CACHE_METHOD_NAME_FILE_CLEAR = "CacheUtils.file.clear";
+const CACHE_METHOD_NAME_FILE_HAS_VALUE = "CacheUtils.file.hasValue";
 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 CACHE_FILE_INSTANCE_METHOD_NAME_HAS_VALUE = "CacheFileInstance.hasValue";
 const MS_PER_MINUTE$1 = 60000;
 const INTERVAL_MINUTES$1 = {
     "1m": 1,
@@ -53877,6 +55606,36 @@ class CacheFnInstance {
                 }
             }
         };
+        /**
+         * Check whether a valid (non-expired) cache entry exists for the current context and arguments.
+         *
+         * Returns `true` if a cached value exists and its interval is still current.
+         * Returns `false` if there is no entry or the cached entry has expired.
+         *
+         * Requires active execution context and method context.
+         *
+         * @param args - Arguments to look up in the cache
+         * @returns `true` if a fresh cached value exists, `false` otherwise
+         */
+        this.hasValue = (...args) => {
+            if (!MethodContextService.hasContext()) {
+                throw new Error("CacheFnInstance hasValue requires method context");
+            }
+            if (!ExecutionContextService.hasContext()) {
+                throw new Error("CacheFnInstance hasValue requires execution context");
+            }
+            const contextKey = CREATE_KEY_FN$1(backtest.methodContextService.context.strategyName, backtest.methodContextService.context.exchangeName, backtest.methodContextService.context.frameName, backtest.executionContextService.context.backtest);
+            const argKey = String(this.key(args));
+            const key = `${contextKey}:${argKey}`;
+            const cached = this._cacheMap.get(key);
+            if (!cached) {
+                return false;
+            }
+            const currentWhen = backtest.executionContextService.context.when;
+            const currentAligned = align$1(currentWhen.getTime(), this.interval);
+            const cachedAligned = align$1(cached.when.getTime(), this.interval);
+            return currentAligned === cachedAligned;
+        };
         /**
          * Garbage collect expired cache entries.
          *
@@ -54001,6 +55760,33 @@ class CacheFileInstance {
             await PersistMeasureAdapter.writeMeasureData({ id: entityKey, data: result, removed: false }, bucket, entityKey);
             return result;
         };
+        /**
+         * Check whether a cached value exists on disk for the given arguments and current interval.
+         *
+         * Returns `true` if a persisted record exists for the current aligned timestamp.
+         * Returns `false` if no record is found.
+         *
+         * Requires active execution context and method context.
+         *
+         * @param args - Arguments forwarded to the key generator
+         * @returns `true` if a cached record exists, `false` otherwise
+         */
+        this.hasValue = async (...args) => {
+            backtest.loggerService.debug(CACHE_FILE_INSTANCE_METHOD_NAME_HAS_VALUE, { args });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("CacheFileInstance hasValue requires method context");
+            }
+            if (!ExecutionContextService.hasContext()) {
+                throw new Error("CacheFileInstance hasValue requires execution context");
+            }
+            const [symbol, ...rest] = args;
+            const { when } = backtest.executionContextService.context;
+            const alignedTs = align$1(when.getTime(), this.interval);
+            const bucket = `${this.name}_${this.interval}_${this.index}`;
+            const entityKey = this.key([symbol, alignedTs, ...rest]);
+            const cached = await PersistMeasureAdapter.readMeasureData(bucket, entityKey);
+            return cached !== null;
+        };
         /**
          * Soft-delete all persisted records for this instance's bucket.
          * After this call the next `run()` will recompute and re-cache the value.
@@ -54087,23 +55873,30 @@ class CacheUtils {
             wrappedFn.clear = () => {
                 backtest.loggerService.info(CACHE_METHOD_NAME_FN_CLEAR);
                 if (!MethodContextService.hasContext()) {
-                    backtest.loggerService.warn(`${CACHE_METHOD_NAME_FN_CLEAR} called without method context, skipping`);
-                    return;
+                    throw new Error(`${CACHE_METHOD_NAME_FN_CLEAR} requires method context`);
                 }
                 if (!ExecutionContextService.hasContext()) {
-                    backtest.loggerService.warn(`${CACHE_METHOD_NAME_FN_CLEAR} called without execution context, skipping`);
-                    return;
+                    throw new Error(`${CACHE_METHOD_NAME_FN_CLEAR} requires execution context`);
                 }
                 this._getFnInstance.get(run)?.clear();
             };
             wrappedFn.gc = () => {
                 backtest.loggerService.info(CACHE_METHOD_NAME_FN_GC);
                 if (!ExecutionContextService.hasContext()) {
-                    backtest.loggerService.warn(`${CACHE_METHOD_NAME_FN_GC} called without execution context, skipping`);
-                    return;
+                    throw new Error(`${CACHE_METHOD_NAME_FN_GC} requires execution context`);
                 }
                 return this._getFnInstance.get(run)?.gc();
             };
+            wrappedFn.hasValue = (...args) => {
+                backtest.loggerService.info(CACHE_METHOD_NAME_FN_HAS_VALUE);
+                if (!MethodContextService.hasContext()) {
+                    throw new Error(`${CACHE_METHOD_NAME_FN_HAS_VALUE} requires method context`);
+                }
+                if (!ExecutionContextService.hasContext()) {
+                    throw new Error(`${CACHE_METHOD_NAME_FN_HAS_VALUE} requires execution context`);
+                }
+                return this._getFnInstance.get(run)?.hasValue(...args) ?? false;
+            };
             return wrappedFn;
         };
         /**
@@ -54155,8 +55948,25 @@ class CacheUtils {
             };
             wrappedFn.clear = async () => {
                 backtest.loggerService.info(CACHE_METHOD_NAME_FILE_CLEAR);
+                if (!MethodContextService.hasContext()) {
+                    throw new Error(`${CACHE_METHOD_NAME_FILE_CLEAR} requires method context`);
+                }
+                if (!ExecutionContextService.hasContext()) {
+                    throw new Error(`${CACHE_METHOD_NAME_FILE_CLEAR} requires execution context`);
+                }
                 await this._getFileInstance.get(run)?.clear();
             };
+            wrappedFn.hasValue = async (...args) => {
+                backtest.loggerService.info(CACHE_METHOD_NAME_FILE_HAS_VALUE);
+                if (!MethodContextService.hasContext()) {
+                    throw new Error(`${CACHE_METHOD_NAME_FILE_HAS_VALUE} requires method context`);
+                }
+                if (!ExecutionContextService.hasContext()) {
+                    throw new Error(`${CACHE_METHOD_NAME_FILE_HAS_VALUE} requires execution context`);
+                }
+                const instance = this._getFileInstance(run, context.interval, context.name, context.key);
+                return await instance.hasValue(...args);
+            };
             return wrappedFn;
         };
         /**
@@ -54225,11 +56035,14 @@ const Cache = new CacheUtils();
 
 const INTERVAL_METHOD_NAME_RUN = "IntervalFnInstance.run";
 const INTERVAL_FILE_INSTANCE_METHOD_NAME_RUN = "IntervalFileInstance.run";
+const INTERVAL_FILE_INSTANCE_METHOD_NAME_HAS_VALUE = "IntervalFileInstance.hasValue";
 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_FN_HAS_VALUE = "IntervalUtils.fn.hasValue";
 const INTERVAL_METHOD_NAME_FILE = "IntervalUtils.file";
 const INTERVAL_METHOD_NAME_FILE_CLEAR = "IntervalUtils.file.clear";
+const INTERVAL_METHOD_NAME_FILE_HAS_VALUE = "IntervalUtils.file.hasValue";
 const INTERVAL_METHOD_NAME_DISPOSE = "IntervalUtils.dispose";
 const INTERVAL_METHOD_NAME_CLEAR = "IntervalUtils.clear";
 const INTERVAL_METHOD_NAME_RESET_COUNTER = "IntervalUtils.resetCounter";
@@ -54387,6 +56200,31 @@ class IntervalFnInstance {
                 }
             }
         };
+        /**
+         * Check whether the function has already fired for the current interval and context.
+         *
+         * Returns `true` if the function fired (non-null result) within the current interval boundary.
+         * Returns `false` if there is no recorded firing for this interval.
+         *
+         * Requires active method context and execution context.
+         *
+         * @param args - Arguments to look up in the state map
+         * @returns `true` if the function has already fired this interval, `false` otherwise
+         */
+        this.hasValue = (...args) => {
+            if (!MethodContextService.hasContext()) {
+                throw new Error("IntervalFnInstance hasValue requires method context");
+            }
+            if (!ExecutionContextService.hasContext()) {
+                throw new Error("IntervalFnInstance hasValue requires execution context");
+            }
+            const contextKey = CREATE_KEY_FN(backtest.methodContextService.context.strategyName, backtest.methodContextService.context.exchangeName, backtest.methodContextService.context.frameName, backtest.executionContextService.context.backtest);
+            const currentWhen = backtest.executionContextService.context.when;
+            const currentAligned = align(currentWhen.getTime(), this.interval);
+            const argKey = this.key(args);
+            const stateKey = `${contextKey}:${argKey}`;
+            return this._stateMap.get(stateKey) === currentAligned;
+        };
         /**
          * Garbage collect expired state entries.
          *
@@ -54508,6 +56346,33 @@ class IntervalFileInstance {
             }
             return result;
         };
+        /**
+         * Check whether the function has already fired for the current interval on disk.
+         *
+         * Returns `true` if a persisted record exists for the current aligned timestamp.
+         * Returns `false` if no record is found.
+         *
+         * Requires active execution context and method context.
+         *
+         * @param args - Arguments forwarded to the key generator
+         * @returns `true` if a fired record exists, `false` otherwise
+         */
+        this.hasValue = async (...args) => {
+            backtest.loggerService.debug(INTERVAL_FILE_INSTANCE_METHOD_NAME_HAS_VALUE, { args });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("IntervalFileInstance hasValue requires method context");
+            }
+            if (!ExecutionContextService.hasContext()) {
+                throw new Error("IntervalFileInstance hasValue requires execution context");
+            }
+            const [symbol, ...rest] = args;
+            const { when } = backtest.executionContextService.context;
+            const alignedMs = align(when.getTime(), this.interval);
+            const bucket = `${this.name}_${this.interval}_${this.index}`;
+            const entityKey = this.key([symbol, alignedMs, ...rest]);
+            const cached = await PersistIntervalAdapter.readIntervalData(bucket, entityKey);
+            return cached !== null;
+        };
         /**
          * Soft-delete all persisted records for this instance's bucket.
          * After this call the function will fire again on the next `run()`.
@@ -54588,23 +56453,30 @@ class IntervalUtils {
             wrappedFn.clear = () => {
                 backtest.loggerService.info(INTERVAL_METHOD_NAME_FN_CLEAR);
                 if (!MethodContextService.hasContext()) {
-                    backtest.loggerService.warn(`${INTERVAL_METHOD_NAME_FN_CLEAR} called without method context, skipping`);
-                    return;
+                    throw new Error(`${INTERVAL_METHOD_NAME_FN_CLEAR} requires method context`);
                 }
                 if (!ExecutionContextService.hasContext()) {
-                    backtest.loggerService.warn(`${INTERVAL_METHOD_NAME_FN_CLEAR} called without execution context, skipping`);
-                    return;
+                    throw new Error(`${INTERVAL_METHOD_NAME_FN_CLEAR} requires execution context`);
                 }
                 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;
+                    throw new Error(`${INTERVAL_METHOD_NAME_FN_GC} requires execution context`);
                 }
                 return this._getInstance.get(run)?.gc();
             };
+            wrappedFn.hasValue = (...args) => {
+                backtest.loggerService.info(INTERVAL_METHOD_NAME_FN_HAS_VALUE);
+                if (!MethodContextService.hasContext()) {
+                    throw new Error(`${INTERVAL_METHOD_NAME_FN_HAS_VALUE} requires method context`);
+                }
+                if (!ExecutionContextService.hasContext()) {
+                    throw new Error(`${INTERVAL_METHOD_NAME_FN_HAS_VALUE} requires execution context`);
+                }
+                return this._getInstance.get(run)?.hasValue(...args) ?? false;
+            };
             return wrappedFn;
         };
         /**
@@ -54647,8 +56519,25 @@ class IntervalUtils {
             };
             wrappedFn.clear = async () => {
                 backtest.loggerService.info(INTERVAL_METHOD_NAME_FILE_CLEAR);
+                if (!MethodContextService.hasContext()) {
+                    throw new Error(`${INTERVAL_METHOD_NAME_FILE_CLEAR} requires method context`);
+                }
+                if (!ExecutionContextService.hasContext()) {
+                    throw new Error(`${INTERVAL_METHOD_NAME_FILE_CLEAR} requires execution context`);
+                }
                 await this._getFileInstance.get(run)?.clear();
             };
+            wrappedFn.hasValue = async (...args) => {
+                backtest.loggerService.info(INTERVAL_METHOD_NAME_FILE_HAS_VALUE);
+                if (!MethodContextService.hasContext()) {
+                    throw new Error(`${INTERVAL_METHOD_NAME_FILE_HAS_VALUE} requires method context`);
+                }
+                if (!ExecutionContextService.hasContext()) {
+                    throw new Error(`${INTERVAL_METHOD_NAME_FILE_HAS_VALUE} requires execution context`);
+                }
+                const instance = this._getFileInstance(run, context.interval, context.name, context.key);
+                return await instance.hasValue(...args);
+            };
             return wrappedFn;
         };
         /**
@@ -55858,17 +57747,23 @@ exports.PersistMeasureAdapter = PersistMeasureAdapter;
 exports.PersistMemoryAdapter = PersistMemoryAdapter;
 exports.PersistNotificationAdapter = PersistNotificationAdapter;
 exports.PersistPartialAdapter = PersistPartialAdapter;
+exports.PersistRecentAdapter = PersistRecentAdapter;
 exports.PersistRiskAdapter = PersistRiskAdapter;
 exports.PersistScheduleAdapter = PersistScheduleAdapter;
 exports.PersistSignalAdapter = PersistSignalAdapter;
 exports.PersistStorageAdapter = PersistStorageAdapter;
 exports.Position = Position;
 exports.PositionSize = PositionSize;
+exports.Recent = Recent;
+exports.RecentBacktest = RecentBacktest;
+exports.RecentLive = RecentLive;
+exports.Reflect = Reflect$1;
 exports.Report = Report;
 exports.ReportBase = ReportBase;
 exports.ReportWriter = ReportWriter;
 exports.Risk = Risk;
 exports.Schedule = Schedule;
+exports.Session = Session;
 exports.Storage = Storage;
 exports.StorageBacktest = StorageBacktest;
 exports.StorageLive = StorageLive;
@@ -55922,6 +57817,9 @@ exports.getDefaultConfig = getDefaultConfig;
 exports.getEffectivePriceOpen = getEffectivePriceOpen;
 exports.getExchangeSchema = getExchangeSchema;
 exports.getFrameSchema = getFrameSchema;
+exports.getLatestSignal = getLatestSignal;
+exports.getMaxDrawdownDistancePnlCost = getMaxDrawdownDistancePnlCost;
+exports.getMaxDrawdownDistancePnlPercentage = getMaxDrawdownDistancePnlPercentage;
 exports.getMode = getMode;
 exports.getNextCandles = getNextCandles;
 exports.getOrderBook = getOrderBook;