backtest-kit 6.11.0 → 6.13.0

package/build/index.mjs

@@ -982,6 +982,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;
@@ -2828,6 +2834,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 = 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;
@@ -6573,7 +6688,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,
@@ -6598,7 +6713,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);
@@ -6765,7 +6880,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);
@@ -6812,7 +6927,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()
@@ -6866,7 +6982,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" };
             }
@@ -6898,7 +7014,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);
@@ -8019,6 +8135,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.
      *
@@ -8083,7 +8237,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);
@@ -8137,7 +8291,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);
@@ -8219,7 +8373,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);
             }
@@ -8250,7 +8404,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);
@@ -8386,7 +8540,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 = {
@@ -8441,7 +8595,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 при закрытии позиции
@@ -8625,7 +8779,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,
@@ -8637,6 +8792,7 @@ class ClientStrategy {
         if (this._scheduledSignal) {
             this._cancelledSignal = Object.assign({}, this._scheduledSignal, {
                 cancelId,
+                cancelNote: payload.note,
             });
             this._scheduledSignal = null;
         }
@@ -8668,7 +8824,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,
@@ -8686,6 +8843,7 @@ class ClientStrategy {
         if (this._scheduledSignal) {
             this._activatedSignal = Object.assign({}, this._scheduledSignal, {
                 activateId,
+                activateNote: payload.note,
             });
             this._scheduledSignal = null;
         }
@@ -8717,7 +8875,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,
@@ -8728,6 +8887,7 @@ class ClientStrategy {
         if (this._pendingSignal) {
             this._closedSignal = Object.assign({}, this._pendingSignal, {
                 closeId,
+                closeNote: payload.note,
             });
             this._pendingSignal = null;
         }
@@ -10110,7 +10270,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);
@@ -10377,7 +10537,7 @@ class StrategyConnectionService {
          * @param backtest - Whether running in backtest mode
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$t(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
+        this.getStrategy = 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,
@@ -11218,6 +11378,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.
          *
@@ -11256,7 +11458,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;
             }
@@ -11277,17 +11479,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.
@@ -11302,17 +11504,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.
@@ -11591,7 +11793,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
@@ -11601,19 +11803,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.
@@ -12425,7 +12627,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);
@@ -12525,7 +12727,7 @@ class RiskConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientRisk instance
          */
-        this.getRisk = memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$s(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
+        this.getRisk = 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,
@@ -12594,7 +12796,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 {
@@ -13638,7 +13840,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);
@@ -13690,7 +13892,7 @@ class ActionConnectionService {
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientAction instance
          */
-        this.getAction = memoize(([actionName, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$r(actionName, strategyName, exchangeName, frameName, backtest), (actionName, strategyName, exchangeName, frameName, backtest) => {
+        this.getAction = 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,
@@ -13901,7 +14103,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;
             }
@@ -13919,7 +14121,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;
 };
 /**
@@ -13943,7 +14145,7 @@ class ExchangeCoreService {
          * @param exchangeName - Name of the exchange to validate
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([exchangeName]) => CREATE_KEY_FN$q(exchangeName), async (exchangeName) => {
+        this.validate = memoize(([exchangeName]) => CREATE_KEY_FN$r(exchangeName), async (exchangeName) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$2, {
                 exchangeName,
             });
@@ -14195,7 +14397,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);
@@ -14227,7 +14429,7 @@ class StrategyCoreService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$p(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$q(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE$1, {
                 context,
             });
@@ -14648,18 +14850,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.
@@ -14675,18 +14877,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.
@@ -15031,7 +15233,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
@@ -15041,19 +15243,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.
@@ -15455,6 +15657,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);
+        };
     }
 }
 
@@ -15527,7 +15767,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);
@@ -15553,7 +15793,7 @@ class RiskGlobalService {
          * @param payload - Payload with riskName, exchangeName and frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$o(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$p(context), async (context) => {
             this.loggerService.log("riskGlobalService validate", {
                 context,
             });
@@ -15631,7 +15871,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);
@@ -15675,7 +15915,7 @@ class ActionCoreService {
          * @param context - Strategy execution context with strategyName, exchangeName and frameName
          * @returns Promise that resolves when all validations complete
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$n(context), async (context) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$o(context), async (context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE, {
                 context,
             });
@@ -20718,7 +20958,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);
@@ -20964,7 +21204,7 @@ class BacktestMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$m(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$a(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = 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.
@@ -21121,7 +21361,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 {
@@ -21183,7 +21423,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);
@@ -21678,7 +21918,7 @@ class LiveMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$l(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$9(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = 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.
@@ -21896,7 +22136,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 {
@@ -21916,7 +22156,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);
@@ -22205,7 +22445,7 @@ class ScheduleMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$k(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new ReportStorage$8(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$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.
@@ -22408,7 +22648,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 {
@@ -22428,7 +22668,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);
@@ -22673,7 +22913,7 @@ class PerformanceMarkdownService {
          * Memoized function to get or create PerformanceStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$j(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName) => new PerformanceStorage(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$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.
@@ -22840,7 +23080,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 {
@@ -23319,7 +23559,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);
@@ -23766,7 +24006,7 @@ class HeatMarkdownService {
          * Memoized function to get or create HeatmapStorage for exchange, frame and backtest mode.
          * Each exchangeName + frameName + backtest mode combination gets its own isolated heatmap storage instance.
          */
-        this.getStorage = memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$i(exchangeName, frameName, backtest), (exchangeName, frameName, backtest) => new HeatmapStorage(exchangeName, frameName, backtest));
+        this.getStorage = 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.
@@ -23984,7 +24224,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 {
@@ -25015,7 +25255,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.
  *
@@ -25137,7 +25377,7 @@ class PartialConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientPartial instance with logger and event emitters
          */
-        this.getPartial = memoize(([signalId, backtest]) => CREATE_KEY_FN$h(signalId, backtest), (signalId, backtest) => {
+        this.getPartial = memoize(([signalId, backtest]) => CREATE_KEY_FN$i(signalId, backtest), (signalId, backtest) => {
             return new ClientPartial({
                 signalId,
                 logger: this.loggerService,
@@ -25227,7 +25467,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);
         };
     }
@@ -25243,7 +25483,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);
@@ -25466,7 +25706,7 @@ class PartialMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$g(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$6(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$h(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$6(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to partial profit/loss signal emitters to receive events.
          * Protected against multiple subscriptions.
@@ -25676,7 +25916,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 {
@@ -25692,7 +25932,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);
@@ -25766,7 +26006,7 @@ class PartialGlobalService {
          * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$f(context), (context, methodName) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$g(context), (context, methodName) => {
             this.loggerService.log("partialGlobalService validate", {
                 context,
                 methodName,
@@ -26221,7 +26461,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.
  *
@@ -26307,7 +26547,7 @@ class BreakevenConnectionService {
          * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientBreakeven instance with logger and event emitter
          */
-        this.getBreakeven = memoize(([signalId, backtest]) => CREATE_KEY_FN$e(signalId, backtest), (signalId, backtest) => {
+        this.getBreakeven = memoize(([signalId, backtest]) => CREATE_KEY_FN$f(signalId, backtest), (signalId, backtest) => {
             return new ClientBreakeven({
                 signalId,
                 logger: this.loggerService,
@@ -26368,7 +26608,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);
         };
     }
@@ -26384,7 +26624,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);
@@ -26559,7 +26799,7 @@ class BreakevenMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$d(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$5(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = 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.
@@ -26748,7 +26988,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 {
@@ -26764,7 +27004,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);
@@ -26838,7 +27078,7 @@ class BreakevenGlobalService {
          * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = memoize(([context]) => CREATE_KEY_FN$c(context), (context, methodName) => {
+        this.validate = memoize(([context]) => CREATE_KEY_FN$d(context), (context, methodName) => {
             this.loggerService.log("breakevenGlobalService validate", {
                 context,
                 methodName,
@@ -27059,7 +27299,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);
@@ -27226,7 +27466,7 @@ class RiskMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy-exchange-frame-backtest combination.
          * Each combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$b(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$4(symbol, strategyName, exchangeName, frameName));
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$c(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => new ReportStorage$4(symbol, strategyName, exchangeName, frameName));
         /**
          * Subscribes to risk rejection emitter to receive rejection events.
          * Protected against multiple subscriptions.
@@ -27415,7 +27655,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 {
@@ -29054,7 +29294,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,
@@ -29067,6 +29307,7 @@ class StrategyReportService {
             await ReportWriter.writeData("strategy", {
                 action: "cancel-scheduled",
                 cancelId,
+                note,
                 symbol,
                 timestamp,
                 createdAt,
@@ -29088,7 +29329,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,
@@ -29101,6 +29342,7 @@ class StrategyReportService {
             await ReportWriter.writeData("strategy", {
                 action: "close-pending",
                 closeId,
+                note,
                 symbol,
                 timestamp,
                 createdAt,
@@ -29350,7 +29592,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,
@@ -29364,6 +29606,7 @@ class StrategyReportService {
             await ReportWriter.writeData("strategy", {
                 action: "activate-scheduled",
                 activateId,
+                note,
                 currentPrice,
                 symbol,
                 timestamp,
@@ -29457,14 +29700,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, {
@@ -29506,7 +29749,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, {
@@ -29794,7 +30037,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);
@@ -30036,7 +30279,7 @@ class StrategyMarkdownService {
          *
          * @internal
          */
-        this.getStorage = 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 = 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.
          *
@@ -30045,8 +30288,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,
@@ -30067,6 +30311,7 @@ class StrategyMarkdownService {
                 action: "cancel-scheduled",
                 pnl,
                 cancelId,
+                note,
                 createdAt,
                 backtest: isBacktest,
             });
@@ -30079,8 +30324,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,
@@ -30101,6 +30347,7 @@ class StrategyMarkdownService {
                 action: "close-pending",
                 pnl,
                 closeId,
+                note,
                 createdAt,
                 backtest: isBacktest,
             });
@@ -30399,8 +30646,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,
@@ -30423,6 +30671,7 @@ class StrategyMarkdownService {
                 pnl,
                 totalPartials,
                 activateId,
+                note,
                 currentPrice,
                 createdAt,
                 backtest: isBacktest,
@@ -30604,7 +30853,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 {
@@ -30627,14 +30876,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, {
@@ -30676,7 +30925,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, {
@@ -30712,7 +30961,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);
@@ -30905,7 +31154,7 @@ let ReportStorage$2 = class ReportStorage {
 class SyncMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = 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 = 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
@@ -31101,7 +31350,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 {
@@ -31114,7 +31363,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);
@@ -31290,7 +31539,7 @@ let ReportStorage$1 = class ReportStorage {
 class HighestProfitMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = 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 = 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
@@ -31456,7 +31705,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 {
@@ -31478,7 +31727,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);
@@ -31521,7 +31770,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 = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$7(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
+        this.getSource = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$8(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
         /**
          * Returns the current market price for the given symbol and context.
          *
@@ -31550,10 +31799,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 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;
         };
@@ -31595,7 +31844,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);
         };
     }
@@ -31613,7 +31862,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);
@@ -31656,7 +31905,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 = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
+        this.getSource = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$7(symbol, strategyName, exchangeName, frameName, backtest), () => new BehaviorSubject());
         /**
          * Returns the current candle timestamp (in milliseconds) for the given symbol and context.
          *
@@ -31684,10 +31933,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 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;
         };
@@ -31729,7 +31978,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);
         };
     }
@@ -31825,7 +32074,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);
@@ -31949,7 +32198,7 @@ class ReportStorage {
 class MaxDrawdownMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.getStorage = 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 = 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`.
@@ -32028,7 +32277,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 {
@@ -35161,6 +35410,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";
@@ -35176,7 +35427,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
@@ -35184,13 +35435,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");
@@ -35200,7 +35451,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.
@@ -35212,7 +35463,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
@@ -35220,13 +35471,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");
@@ -35236,7 +35487,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).
@@ -35699,7 +35950,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
@@ -35707,13 +35958,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");
@@ -35723,7 +35974,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.
@@ -36911,6 +37162,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.
@@ -38584,6 +38893,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";
@@ -39965,6 +40276,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.
@@ -40099,7 +40466,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
@@ -40109,14 +40476,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);
@@ -40129,7 +40496,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.
@@ -40140,7 +40507,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
@@ -40150,14 +40517,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);
@@ -40170,7 +40537,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).
@@ -40806,7 +41173,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
@@ -40816,14 +41183,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);
@@ -40836,7 +41203,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.
@@ -41094,6 +41461,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";
@@ -42618,6 +42987,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.
@@ -42759,7 +43192,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
@@ -42769,14 +43202,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);
@@ -42793,7 +43226,7 @@ class LiveUtils {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
-            }, cancelId);
+            }, payload);
         };
         /**
          * Closes the pending signal without stopping the strategy.
@@ -42804,7 +43237,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
@@ -42813,14 +43246,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);
@@ -42837,7 +43270,7 @@ class LiveUtils {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
-            }, closeId);
+            }, payload);
         };
         /**
          * Executes partial close at profit level (moving toward TP).
@@ -43631,7 +44064,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
@@ -43640,14 +44073,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);
@@ -43664,7 +44097,7 @@ class LiveUtils {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
-            }, activateId);
+            }, payload);
         };
         /**
          * Adds a new DCA entry to the active pending signal.
@@ -44910,6 +45343,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 = 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 = compose(() => unBacktestPingActive());
+            }
+            {
+                const unLivePingActive = activePingSubject
+                    .filter(({ backtest }) => !backtest)
+                    .connect((event) => RecentLive.handleActivePing(event));
+                unLive = compose(() => unLivePingActive());
+            }
+            const unEnable = () => this.enable.clear();
+            return 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;
@@ -48160,6 +49090,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 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";
@@ -49735,6 +50726,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.
  *
@@ -53662,12 +55388,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,
@@ -53857,6 +55586,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.
          *
@@ -53981,6 +55740,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.
@@ -54067,23 +55853,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;
         };
         /**
@@ -54135,8 +55928,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;
         };
         /**
@@ -54205,11 +56015,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";
@@ -54367,6 +56180,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.
          *
@@ -54488,6 +56326,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()`.
@@ -54568,23 +56433,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;
         };
         /**
@@ -54627,8 +56499,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;
         };
         /**
@@ -55802,4 +57691,4 @@ const validateSignal = (signal, currentPrice) => {
     return !errors.length;
 };
 
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistIntervalAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistMemoryAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, Position, PositionSize, Report, ReportBase, ReportWriter, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Sync, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistIntervalAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistMemoryAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRecentAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, Storage, StorageBacktest, StorageLive, Strategy, Sync, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getRawCandles, getRiskSchema, getScheduledSignal, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };