backtest-kit 1.6.9 → 1.7.2

package/build/index.mjs

@@ -2093,6 +2093,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         symbol: self.params.execution.context.symbol,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         currentPrice,
         timestamp: currentTime,
     }))) {
@@ -2119,6 +2120,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
                 symbol: self.params.execution.context.symbol,
                 exchangeName: self.params.method.context.exchangeName,
                 strategyName: self.params.method.context.strategyName,
+                frameName: self.params.method.context.frameName,
                 scheduledAt: currentTime,
                 pendingAt: currentTime, // Для immediate signal оба времени одинаковые
                 _isScheduled: false,
@@ -2139,6 +2141,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
             symbol: self.params.execution.context.symbol,
             exchangeName: self.params.method.context.exchangeName,
             strategyName: self.params.method.context.strategyName,
+            frameName: self.params.method.context.frameName,
             scheduledAt: currentTime,
             pendingAt: currentTime, // Временно, обновится при активации
             _isScheduled: true,
@@ -2155,6 +2158,7 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         symbol: self.params.execution.context.symbol,
         exchangeName: self.params.method.context.exchangeName,
         strategyName: self.params.method.context.strategyName,
+        frameName: self.params.method.context.frameName,
         scheduledAt: currentTime,
         pendingAt: currentTime, // Для immediate signal оба времени одинаковые
         _isScheduled: false,
@@ -2248,6 +2252,7 @@ const CHECK_SCHEDULED_SIGNAL_TIMEOUT_FN = async (self, scheduled, currentPrice)
         closeTimestamp: currentTime,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         symbol: self.params.execution.context.symbol,
         backtest: self.params.execution.context.backtest,
         reason: "timeout",
@@ -2305,6 +2310,7 @@ const CANCEL_SCHEDULED_SIGNAL_BY_STOPLOSS_FN = async (self, scheduled, currentPr
         closeTimestamp: self.params.execution.context.when.getTime(),
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         symbol: self.params.execution.context.symbol,
         backtest: self.params.execution.context.backtest,
         reason: "price_reject",
@@ -2343,6 +2349,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
         pendingSignal: scheduled,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         currentPrice: scheduled.priceOpen,
         timestamp: activationTime,
     }))) {
@@ -2364,6 +2371,8 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
     await self.params.risk.addSignal(self.params.execution.context.symbol, {
         strategyName: self.params.method.context.strategyName,
         riskName: self.params.riskName,
+        exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
     });
     if (self.params.callbacks?.onOpen) {
         self.params.callbacks.onOpen(self.params.execution.context.symbol, self._pendingSignal, self._pendingSignal.priceOpen, self.params.execution.context.backtest);
@@ -2373,6 +2382,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_FN = async (self, scheduled, activationTimestamp
         signal: self._pendingSignal,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         symbol: self.params.execution.context.symbol,
         currentPrice: self._pendingSignal.priceOpen,
         backtest: self.params.execution.context.backtest,
@@ -2409,6 +2419,7 @@ const RETURN_SCHEDULED_SIGNAL_ACTIVE_FN = async (self, scheduled, currentPrice)
         currentPrice: currentPrice,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         symbol: self.params.execution.context.symbol,
         percentTp: 0,
         percentSl: 0,
@@ -2436,6 +2447,7 @@ const OPEN_NEW_SCHEDULED_SIGNAL_FN = async (self, signal) => {
         signal: signal,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         symbol: self.params.execution.context.symbol,
         currentPrice: currentPrice,
         backtest: self.params.execution.context.backtest,
@@ -2451,6 +2463,7 @@ const OPEN_NEW_PENDING_SIGNAL_FN = async (self, signal) => {
         symbol: self.params.execution.context.symbol,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         currentPrice: signal.priceOpen,
         timestamp: self.params.execution.context.when.getTime(),
     }))) {
@@ -2459,6 +2472,8 @@ const OPEN_NEW_PENDING_SIGNAL_FN = async (self, signal) => {
     await self.params.risk.addSignal(self.params.execution.context.symbol, {
         strategyName: self.params.method.context.strategyName,
         riskName: self.params.riskName,
+        exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
     });
     if (self.params.callbacks?.onOpen) {
         self.params.callbacks.onOpen(self.params.execution.context.symbol, signal, signal.priceOpen, self.params.execution.context.backtest);
@@ -2468,6 +2483,7 @@ const OPEN_NEW_PENDING_SIGNAL_FN = async (self, signal) => {
         signal: signal,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         symbol: self.params.execution.context.symbol,
         currentPrice: signal.priceOpen,
         backtest: self.params.execution.context.backtest,
@@ -2523,6 +2539,8 @@ const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason)
     await self.params.risk.removeSignal(self.params.execution.context.symbol, {
         strategyName: self.params.method.context.strategyName,
         riskName: self.params.riskName,
+        exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
     });
     await self.setPendingSignal(null);
     const result = {
@@ -2534,6 +2552,7 @@ const CLOSE_PENDING_SIGNAL_FN = async (self, signal, currentPrice, closeReason)
         pnl: pnl,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         symbol: self.params.execution.context.symbol,
         backtest: self.params.execution.context.backtest,
     };
@@ -2602,6 +2621,7 @@ const RETURN_PENDING_SIGNAL_ACTIVE_FN = async (self, signal, currentPrice) => {
         currentPrice: currentPrice,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         symbol: self.params.execution.context.symbol,
         percentTp,
         percentSl,
@@ -2621,6 +2641,7 @@ const RETURN_IDLE_FN = async (self, currentPrice) => {
         signal: null,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         symbol: self.params.execution.context.symbol,
         currentPrice: currentPrice,
         backtest: self.params.execution.context.backtest,
@@ -2650,6 +2671,7 @@ const CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, averagePr
         closeTimestamp: closeTimestamp,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         symbol: self.params.execution.context.symbol,
         backtest: self.params.execution.context.backtest,
         reason,
@@ -2685,6 +2707,7 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
         symbol: self.params.execution.context.symbol,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         currentPrice: scheduled.priceOpen,
         timestamp: activationTime,
     }))) {
@@ -2706,6 +2729,8 @@ const ACTIVATE_SCHEDULED_SIGNAL_IN_BACKTEST_FN = async (self, scheduled, activat
     await self.params.risk.addSignal(self.params.execution.context.symbol, {
         strategyName: self.params.method.context.strategyName,
         riskName: self.params.riskName,
+        exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
     });
     if (self.params.callbacks?.onOpen) {
         self.params.callbacks.onOpen(self.params.execution.context.symbol, activatedSignal, activatedSignal.priceOpen, self.params.execution.context.backtest);
@@ -2736,6 +2761,8 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
     await self.params.risk.removeSignal(self.params.execution.context.symbol, {
         strategyName: self.params.method.context.strategyName,
         riskName: self.params.riskName,
+        exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
     });
     await self.setPendingSignal(null);
     const result = {
@@ -2747,6 +2774,7 @@ const CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, signal, averagePrice, c
         pnl: pnl,
         strategyName: self.params.method.context.strategyName,
         exchangeName: self.params.method.context.exchangeName,
+        frameName: self.params.method.context.frameName,
         symbol: self.params.execution.context.symbol,
         backtest: self.params.execution.context.backtest,
     };
@@ -3043,10 +3071,9 @@ class ClientStrategy {
      * If no signal is pending, returns null.
      * @returns Promise resolving to the pending signal or null.
      */
-    async getPendingSignal(symbol, strategyName) {
+    async getPendingSignal(symbol) {
         this.params.logger.debug("ClientStrategy getPendingSignal", {
             symbol,
-            strategyName,
         });
         return this._pendingSignal;
     }
@@ -3055,10 +3082,9 @@ class ClientStrategy {
      * If no scheduled signal exists, returns null.
      * @returns Promise resolving to the scheduled signal or null.
      */
-    async getScheduledSignal(symbol, strategyName) {
+    async getScheduledSignal(symbol) {
         this.params.logger.debug("ClientStrategy getScheduledSignal", {
             symbol,
-            strategyName,
         });
         return this._scheduledSignal;
     }
@@ -3069,13 +3095,12 @@ class ClientStrategy {
      * not continue processing new ticks or signals.
      *
      * @param symbol - Trading pair symbol
-     * @param strategyName - Name of the strategy
      * @returns Promise resolving to true if strategy is stopped, false otherwise
      */
-    async getStopped(symbol, strategyName) {
+    async getStopped(symbol) {
         this.params.logger.debug("ClientStrategy getStopped", {
             symbol,
-            strategyName,
+            strategyName: this.params.method.context.strategyName,
         });
         return this._isStopped;
     }
@@ -3141,6 +3166,7 @@ class ClientStrategy {
                 closeTimestamp: currentTime,
                 strategyName: this.params.method.context.strategyName,
                 exchangeName: this.params.method.context.exchangeName,
+                frameName: this.params.method.context.frameName,
                 symbol: this.params.execution.context.symbol,
                 backtest: this.params.execution.context.backtest,
                 reason: "user",
@@ -3254,6 +3280,7 @@ class ClientStrategy {
                 closeTimestamp: this.params.execution.context.when.getTime(),
                 strategyName: this.params.method.context.strategyName,
                 exchangeName: this.params.method.context.exchangeName,
+                frameName: this.params.method.context.frameName,
                 symbol: this.params.execution.context.symbol,
                 backtest: true,
                 reason: "user",
@@ -3316,6 +3343,7 @@ class ClientStrategy {
                         percentTp: 0,
                         strategyName: this.params.method.context.strategyName,
                         exchangeName: this.params.method.context.exchangeName,
+                        frameName: this.params.method.context.frameName,
                         symbol: this.params.execution.context.symbol,
                         backtest: this.params.execution.context.backtest,
                     };
@@ -3372,13 +3400,11 @@ class ClientStrategy {
      * // Existing signal will continue until natural close
      * ```
      */
-    async stop(symbol, strategyName, backtest) {
+    async stop(symbol, backtest) {
         this.params.logger.debug("ClientStrategy stop", {
             symbol,
-            strategyName,
             hasPendingSignal: this._pendingSignal !== null,
             hasScheduledSignal: this._scheduledSignal !== null,
-            backtest,
         });
         this._isStopped = true;
         // Clear scheduled signal if exists
@@ -3389,7 +3415,7 @@ class ClientStrategy {
         if (backtest) {
             return;
         }
-        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, strategyName);
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName);
     }
     /**
      * Cancels the scheduled signal without stopping the strategy.
@@ -3412,12 +3438,10 @@ class ClientStrategy {
      * // Strategy continues, can generate new signals
      * ```
      */
-    async cancel(symbol, strategyName, backtest, cancelId) {
+    async cancel(symbol, backtest, cancelId) {
         this.params.logger.debug("ClientStrategy cancel", {
             symbol,
-            strategyName,
             hasScheduledSignal: this._scheduledSignal !== null,
-            backtest,
             cancelId,
         });
         // Save cancelled signal for next tick to emit cancelled event
@@ -3430,7 +3454,7 @@ class ClientStrategy {
         if (backtest) {
             return;
         }
-        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, strategyName);
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName);
     }
 }
 
@@ -3506,7 +3530,7 @@ class MergeRisk {
      * Used to track active positions across all risk management systems.
      *
      * @param symbol - Trading pair symbol
-     * @param context - Context with strategyName and riskName
+     * @param context - Context with strategyName, riskName, exchangeName and frameName
      * @returns Promise that resolves when all risks have registered the signal
      */
     async addSignal(symbol, context) {
@@ -3523,7 +3547,7 @@ class MergeRisk {
      * Used to update risk state when a position closes.
      *
      * @param symbol - Trading pair symbol
-     * @param context - Context with strategyName and riskName
+     * @param context - Context with strategyName, riskName, exchangeName and frameName
      * @returns Promise that resolves when all risks have removed the signal
      */
     async removeSignal(symbol, context) {
@@ -3595,20 +3619,20 @@ class RiskUtils {
          * }
          * ```
          */
-        this.getData = async (symbol, strategyName, backtest = false) => {
+        this.getData = async (symbol, context, backtest = false) => {
             backtest$1.loggerService.info(RISK_METHOD_NAME_GET_DATA, {
                 symbol,
-                strategyName,
+                strategyName: context.strategyName,
             });
-            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_DATA);
+            backtest$1.strategyValidationService.validate(context.strategyName, RISK_METHOD_NAME_GET_DATA);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName &&
                     backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA);
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA));
             }
-            return await backtest$1.riskMarkdownService.getData(symbol, strategyName, backtest);
+            return await backtest$1.riskMarkdownService.getData(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
         };
         /**
          * Generates markdown report with all risk rejection events for a symbol-strategy pair.
@@ -3651,20 +3675,20 @@ class RiskUtils {
          * // - my-strategy: 1
          * ```
          */
-        this.getReport = async (symbol, strategyName, backtest = false, columns) => {
+        this.getReport = async (symbol, context, backtest = false, columns) => {
             backtest$1.loggerService.info(RISK_METHOD_NAME_GET_REPORT, {
                 symbol,
-                strategyName,
+                strategyName: context.strategyName,
             });
-            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_REPORT);
+            backtest$1.strategyValidationService.validate(context.strategyName, RISK_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName &&
                     backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT);
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.riskMarkdownService.getReport(symbol, strategyName, backtest, columns);
+            return await backtest$1.riskMarkdownService.getReport(symbol, context.strategyName, context.exchangeName, context.frameName, backtest, columns);
         };
         /**
          * Generates and saves markdown report to file.
@@ -3698,21 +3722,21 @@ class RiskUtils {
          * }
          * ```
          */
-        this.dump = async (symbol, strategyName, backtest = false, path, columns) => {
+        this.dump = async (symbol, context, backtest = false, path, columns) => {
             backtest$1.loggerService.info(RISK_METHOD_NAME_DUMP, {
                 symbol,
-                strategyName,
+                strategyName: context.strategyName,
                 path,
             });
-            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_DUMP);
+            backtest$1.strategyValidationService.validate(context.strategyName, RISK_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName &&
                     backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP);
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP));
             }
-            await backtest$1.riskMarkdownService.dump(symbol, strategyName, backtest, path, columns);
+            await backtest$1.riskMarkdownService.dump(symbol, context.strategyName, context.exchangeName, context.frameName, backtest, path, columns);
         };
     }
 }
@@ -3745,10 +3769,12 @@ const NOOP_RISK = {
  * Determines the appropriate IRisk instance based on provided riskName and riskList.
  * @param dto - Object containing riskName and riskList
  * @param backtest - Whether running in backtest mode
+ * @param exchangeName - Exchange name for risk isolation
+ * @param frameName - Frame name for risk isolation
  * @param self - Reference to StrategyConnectionService instance
  * @returns Configured IRisk instance (single or merged)
  */
-const GET_RISK_FN = (dto, backtest, self) => {
+const GET_RISK_FN = (dto, backtest, exchangeName, frameName, self) => {
     const hasRiskName = !!dto.riskName;
     const hasRiskList = !!dto.riskList?.length;
     // Нет ни riskName, ни riskList
@@ -3757,27 +3783,35 @@ const GET_RISK_FN = (dto, backtest, self) => {
     }
     // Есть только riskName (без riskList)
     if (hasRiskName && !hasRiskList) {
-        return self.riskConnectionService.getRisk(dto.riskName, backtest);
+        return self.riskConnectionService.getRisk(dto.riskName, exchangeName, frameName, backtest);
     }
     // Есть только riskList (без riskName)
     if (!hasRiskName && hasRiskList) {
-        return new MergeRisk(dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName, backtest)));
+        return new MergeRisk(dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName, exchangeName, frameName, backtest)));
     }
     // Есть и riskName, и riskList - объединяем (riskName в начало)
     return new MergeRisk([
-        self.riskConnectionService.getRisk(dto.riskName, backtest),
-        ...dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName, backtest)),
+        self.riskConnectionService.getRisk(dto.riskName, exchangeName, frameName, backtest),
+        ...dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName, exchangeName, frameName, backtest)),
     ]);
 };
 /**
  * Creates a unique key for memoizing ClientStrategy instances.
- * Key format: "symbol:strategyName:backtest" or "symbol:strategyName:live"
+ * Key format: "symbol:strategyName:exchangeName:frameName:backtest" or "symbol:strategyName:exchangeName:live"
  * @param symbol - Trading pair symbol
  * @param strategyName - Name of the strategy
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name (empty string for live)
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$b = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$b = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
 /**
  * Callback function for emitting ping events to pingSubject.
  *
@@ -3826,32 +3860,34 @@ class StrategyConnectionService {
         this.strategySchemaService = inject(TYPES.strategySchemaService);
         this.riskConnectionService = inject(TYPES.riskConnectionService);
         this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
-        this.methodContextService = inject(TYPES.methodContextService);
         this.partialConnectionService = inject(TYPES.partialConnectionService);
         /**
-         * Retrieves memoized ClientStrategy instance for given symbol-strategy pair.
+         * Retrieves memoized ClientStrategy instance for given symbol-strategy pair with exchange and frame isolation.
          *
          * Creates ClientStrategy on first call, returns cached instance on subsequent calls.
-         * Cache key is symbol:strategyName string.
+         * Cache key includes exchangeName and frameName for proper isolation.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Name of registered strategy schema
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name (empty string for live)
+         * @param backtest - Whether running in backtest mode
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = memoize(([symbol, strategyName, backtest]) => CREATE_KEY_FN$b(symbol, strategyName, backtest), (symbol, strategyName, backtest) => {
+        this.getStrategy = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$b(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => {
             const { riskName = "", riskList = [], getSignal, interval, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
                 interval,
                 execution: this.executionContextService,
-                method: this.methodContextService,
+                method: { context: { strategyName, exchangeName, frameName } },
                 logger: this.loggerService,
                 partial: this.partialConnectionService,
                 exchange: this.exchangeConnectionService,
                 risk: GET_RISK_FN({
                     riskName,
                     riskList,
-                }, backtest, this),
+                }, backtest, exchangeName, frameName, this),
                 riskName,
                 strategyName,
                 getSignal,
@@ -3864,38 +3900,40 @@ class StrategyConnectionService {
          * If no active signal exists, returns null.
          * Used internally for monitoring TP/SL and time expiration.
          *
+         * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
-         * @param strategyName - Name of strategy to get pending signal for
+         * @param context - Execution context with strategyName, exchangeName, frameName
          *
          * @returns Promise resolving to pending signal or null
          */
-        this.getPendingSignal = async (backtest, symbol, strategyName) => {
+        this.getPendingSignal = async (backtest, symbol, context) => {
             this.loggerService.log("strategyConnectionService getPendingSignal", {
                 symbol,
-                strategyName,
+                context,
                 backtest,
             });
-            const strategy = this.getStrategy(symbol, strategyName, backtest);
-            return await strategy.getPendingSignal(symbol, strategyName);
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getPendingSignal(symbol);
         };
         /**
          * Retrieves the currently active scheduled signal for the strategy.
          * If no scheduled signal exists, returns null.
          * Used internally for monitoring scheduled signal activation.
          *
+         * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
-         * @param strategyName - Name of strategy to get scheduled signal for
+         * @param context - Execution context with strategyName, exchangeName, frameName
          *
          * @returns Promise resolving to scheduled signal or null
          */
-        this.getScheduledSignal = async (backtest, symbol, strategyName) => {
+        this.getScheduledSignal = async (backtest, symbol, context) => {
             this.loggerService.log("strategyConnectionService getScheduledSignal", {
                 symbol,
-                strategyName,
+                context,
                 backtest,
             });
-            const strategy = this.getStrategy(symbol, strategyName, backtest);
-            return await strategy.getScheduledSignal(symbol, strategyName);
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getScheduledSignal(symbol);
         };
         /**
          * Retrieves the stopped state of the strategy.
@@ -3903,18 +3941,19 @@ class StrategyConnectionService {
          * Delegates to the underlying strategy instance to check if it has been
          * marked as stopped and should cease operation.
          *
+         * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
-         * @param strategyName - Name of the strategy
+         * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise resolving to true if strategy is stopped, false otherwise
          */
-        this.getStopped = async (backtest, symbol, strategyName) => {
+        this.getStopped = async (backtest, symbol, context) => {
             this.loggerService.log("strategyConnectionService getStopped", {
                 symbol,
-                strategyName,
+                context,
                 backtest,
             });
-            const strategy = this.getStrategy(symbol, strategyName, backtest);
-            return await strategy.getStopped(symbol, strategyName);
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.getStopped(symbol);
         };
         /**
          * Executes live trading tick for current strategy.
@@ -3923,18 +3962,19 @@ class StrategyConnectionService {
          * Evaluates current market conditions and returns signal state.
          *
          * @param symbol - Trading pair symbol
-         * @param strategyName - Name of strategy to tick
+         * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise resolving to tick result (idle, opened, active, closed)
          */
-        this.tick = async (symbol, strategyName) => {
+        this.tick = async (symbol, context) => {
+            const backtest = this.executionContextService.context.backtest;
             this.loggerService.log("strategyConnectionService tick", {
                 symbol,
-                strategyName,
+                context,
+                backtest,
             });
-            const backtest = this.executionContextService.context.backtest;
-            const strategy = this.getStrategy(symbol, strategyName, backtest);
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             await strategy.waitForInit();
-            const tick = await strategy.tick(symbol, strategyName);
+            const tick = await strategy.tick(symbol, context.strategyName);
             {
                 if (this.executionContextService.context.backtest) {
                     await signalBacktestEmitter.next(tick);
@@ -3953,24 +3993,28 @@ class StrategyConnectionService {
          * Evaluates strategy signals against historical data.
          *
          * @param symbol - Trading pair symbol
-         * @param strategyName - Name of strategy to backtest
+         * @param context - Execution context with strategyName, exchangeName, frameName
          * @param candles - Array of historical candle data to backtest
          * @returns Promise resolving to backtest result (signal or idle)
          */
-        this.backtest = async (symbol, strategyName, candles) => {
+        this.backtest = async (symbol, context, candles) => {
+            const backtest = this.executionContextService.context.backtest;
             this.loggerService.log("strategyConnectionService backtest", {
                 symbol,
-                strategyName,
+                context,
                 candleCount: candles.length,
+                backtest,
             });
-            const backtest = this.executionContextService.context.backtest;
-            const strategy = this.getStrategy(symbol, strategyName, backtest);
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             await strategy.waitForInit();
-            const tick = await strategy.backtest(symbol, strategyName, candles);
+            const tick = await strategy.backtest(symbol, context.strategyName, candles);
             {
                 if (this.executionContextService.context.backtest) {
                     await signalBacktestEmitter.next(tick);
                 }
+                if (!this.executionContextService.context.backtest) {
+                    await signalLiveEmitter.next(tick);
+                }
                 await signalEmitter.next(tick);
             }
             return tick;
@@ -3981,16 +4025,18 @@ class StrategyConnectionService {
          * Delegates to ClientStrategy.stop() which sets internal flag to prevent
          * getSignal from being called on subsequent ticks.
          *
+         * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
-         * @param strategyName - Name of strategy to stop
+         * @param ctx - Context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (backtest, ctx) => {
+        this.stop = async (backtest, symbol, context) => {
             this.loggerService.log("strategyConnectionService stop", {
-                ctx,
+                symbol,
+                context,
             });
-            const strategy = this.getStrategy(ctx.symbol, ctx.strategyName, backtest);
-            await strategy.stop(ctx.symbol, ctx.strategyName, backtest);
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await strategy.stop(symbol, backtest);
         };
         /**
          * Clears the memoized ClientStrategy instance from cache.
@@ -3998,14 +4044,14 @@ class StrategyConnectionService {
          * Forces re-initialization of strategy on next getStrategy call.
          * Useful for resetting strategy state or releasing resources.
          *
-         * @param ctx - Optional context with symbol and strategyName (clears all if not provided)
+         * @param payload - Optional payload with symbol, context and backtest flag (clears all if not provided)
          */
-        this.clear = async (backtest, ctx) => {
+        this.clear = async (payload) => {
             this.loggerService.log("strategyConnectionService clear", {
-                ctx,
+                payload,
             });
-            if (ctx) {
-                const key = CREATE_KEY_FN$b(ctx.symbol, ctx.strategyName, backtest);
+            if (payload) {
+                const key = CREATE_KEY_FN$b(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStrategy.clear(key);
             }
             else {
@@ -4022,17 +4068,19 @@ class StrategyConnectionService {
          * detects the scheduled signal was cancelled.
          *
          * @param backtest - Whether running in backtest mode
-         * @param ctx - Context with symbol and strategyName
+         * @param symbol - Trading pair symbol
+         * @param ctx - Context with strategyName, exchangeName, frameName
          * @param cancelId - Optional cancellation ID for user-initiated cancellations
          * @returns Promise that resolves when scheduled signal is cancelled
          */
-        this.cancel = async (backtest, ctx, cancelId) => {
+        this.cancel = async (backtest, symbol, context, cancelId) => {
             this.loggerService.log("strategyConnectionService cancel", {
-                ctx,
+                symbol,
+                context,
                 cancelId,
             });
-            const strategy = this.getStrategy(ctx.symbol, ctx.strategyName, backtest);
-            await strategy.cancel(ctx.symbol, ctx.strategyName, backtest, cancelId);
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await strategy.cancel(symbol, backtest, cancelId);
         };
     }
 }
@@ -4418,7 +4466,7 @@ const get = (object, path) => {
 /** Symbol indicating that positions need to be fetched from persistence */
 const POSITION_NEED_FETCH = Symbol("risk-need-fetch");
 /** Key generator for active position map */
-const GET_KEY_FN = (strategyName, symbol) => `${strategyName}:${symbol}`;
+const CREATE_NAME_FN = (strategyName, exchangeName, symbol) => `${strategyName}_${exchangeName}_${symbol}`;
 /** Wrapper to execute risk validation function with error handling */
 const DO_VALIDATION_FN = async (validation, params) => {
     try {
@@ -4578,12 +4626,11 @@ class ClientRisk {
         if (this._activePositions === POSITION_NEED_FETCH) {
             await this.waitForInit();
         }
-        const key = GET_KEY_FN(context.strategyName, symbol);
+        const key = CREATE_NAME_FN(context.strategyName, context.exchangeName, symbol);
         const riskMap = this._activePositions;
         riskMap.set(key, {
-            signal: null, // Signal details not needed for position tracking
             strategyName: context.strategyName,
-            exchangeName: "",
+            exchangeName: context.exchangeName,
             openTimestamp: Date.now(),
         });
         await this._updatePositions();
@@ -4601,7 +4648,7 @@ class ClientRisk {
         if (this._activePositions === POSITION_NEED_FETCH) {
             await this.waitForInit();
         }
-        const key = GET_KEY_FN(context.strategyName, symbol);
+        const key = CREATE_NAME_FN(context.strategyName, context.exchangeName, symbol);
         const riskMap = this._activePositions;
         riskMap.delete(key);
         await this._updatePositions();
@@ -4610,12 +4657,20 @@ class ClientRisk {
 
 /**
  * Creates a unique key for memoizing ClientRisk instances.
- * Key format: "riskName:backtest" or "riskName:live"
+ * Key format: "riskName:exchangeName:frameName:backtest" or "riskName:exchangeName:live"
  * @param riskName - Name of the risk schema
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name (empty string for live)
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$a = (riskName, backtest) => `${riskName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$a = (riskName, exchangeName, frameName, backtest) => {
+    const parts = [riskName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
 /**
  * Callback function for emitting risk rejection events to riskSubject.
  *
@@ -4628,16 +4683,19 @@ const CREATE_KEY_FN$a = (riskName, backtest) => `${riskName}:${backtest ? "backt
  * @param rejectionResult - Rejection result with id and note
  * @param timestamp - Event timestamp in milliseconds
  * @param backtest - True if backtest mode, false if live mode
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name
  */
-const COMMIT_REJECTION_FN = async (symbol, params, activePositionCount, rejectionResult, timestamp, backtest) => await riskSubject.next({
+const COMMIT_REJECTION_FN = async (symbol, params, activePositionCount, rejectionResult, timestamp, backtest, exchangeName, frameName) => await riskSubject.next({
     symbol,
     pendingSignal: params.pendingSignal,
     strategyName: params.strategyName,
-    exchangeName: params.exchangeName,
+    exchangeName,
     currentPrice: params.currentPrice,
     activePositionCount,
     rejectionId: rejectionResult.id,
     rejectionNote: rejectionResult.note,
+    frameName,
     timestamp,
     backtest,
 });
@@ -4678,22 +4736,24 @@ class RiskConnectionService {
         this.loggerService = inject(TYPES.loggerService);
         this.riskSchemaService = inject(TYPES.riskSchemaService);
         /**
-         * Retrieves memoized ClientRisk instance for given risk name and backtest mode.
+         * Retrieves memoized ClientRisk instance for given risk name, exchange, frame and backtest mode.
          *
          * Creates ClientRisk on first call, returns cached instance on subsequent calls.
-         * Cache key is "riskName:backtest" string to separate live and backtest instances.
+         * Cache key includes exchangeName and frameName to isolate risk per exchange+frame.
          *
          * @param riskName - Name of registered risk schema
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name (empty string for live)
          * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientRisk instance
          */
-        this.getRisk = memoize(([riskName, backtest]) => CREATE_KEY_FN$a(riskName, backtest), (riskName, backtest) => {
+        this.getRisk = memoize(([riskName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$a(riskName, exchangeName, frameName, backtest), (riskName, exchangeName, frameName, backtest) => {
             const schema = this.riskSchemaService.get(riskName);
             return new ClientRisk({
                 ...schema,
                 logger: this.loggerService,
                 backtest,
-                onRejected: COMMIT_REJECTION_FN,
+                onRejected: (symbol, params, activePositionCount, rejectionResult, timestamp, backtest) => COMMIT_REJECTION_FN(symbol, params, activePositionCount, rejectionResult, timestamp, backtest, exchangeName, frameName),
             });
         });
         /**
@@ -4704,57 +4764,55 @@ class RiskConnectionService {
          * ClientRisk will emit riskSubject event via onRejected callback when signal is rejected.
          *
          * @param params - Risk check arguments (portfolio state, position details)
-         * @param context - Execution context with risk name and backtest mode
+         * @param payload - Execution payload with risk name, exchangeName, frameName and backtest mode
          * @returns Promise resolving to risk check result
          */
-        this.checkSignal = async (params, context) => {
+        this.checkSignal = async (params, payload) => {
             this.loggerService.log("riskConnectionService checkSignal", {
                 symbol: params.symbol,
-                context,
+                payload,
             });
-            return await this.getRisk(context.riskName, context.backtest).checkSignal(params);
+            return await this.getRisk(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest).checkSignal(params);
         };
         /**
          * Registers an opened signal with the risk management system.
          * Routes to appropriate ClientRisk instance.
          *
          * @param symbol - Trading pair symbol
-         * @param context - Context information (strategyName, riskName, backtest)
+         * @param payload - Payload information (strategyName, riskName, exchangeName, frameName, backtest)
          */
-        this.addSignal = async (symbol, context) => {
+        this.addSignal = async (symbol, payload) => {
             this.loggerService.log("riskConnectionService addSignal", {
                 symbol,
-                context,
+                payload,
             });
-            await this.getRisk(context.riskName, context.backtest).addSignal(symbol, context);
+            await this.getRisk(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest).addSignal(symbol, payload);
         };
         /**
          * Removes a closed signal from the risk management system.
          * Routes to appropriate ClientRisk instance.
          *
          * @param symbol - Trading pair symbol
-         * @param context - Context information (strategyName, riskName, backtest)
+         * @param payload - Payload information (strategyName, riskName, exchangeName, frameName, backtest)
          */
-        this.removeSignal = async (symbol, context) => {
+        this.removeSignal = async (symbol, payload) => {
             this.loggerService.log("riskConnectionService removeSignal", {
                 symbol,
-                context,
+                payload,
             });
-            await this.getRisk(context.riskName, context.backtest).removeSignal(symbol, context);
+            await this.getRisk(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest).removeSignal(symbol, payload);
         };
         /**
          * Clears the cached ClientRisk instance for the given risk name.
          *
-         * @param backtest - Whether running in backtest mode
-         * @param ctx - Optional context with riskName (clears all if not provided)
+         * @param payload - Optional payload with riskName, exchangeName, frameName, backtest (clears all if not provided)
          */
-        this.clear = async (backtest, ctx) => {
+        this.clear = async (payload) => {
             this.loggerService.log("riskConnectionService clear", {
-                ctx,
-                backtest,
+                payload,
             });
-            if (ctx) {
-                const key = CREATE_KEY_FN$a(ctx.riskName, backtest);
+            if (payload) {
+                const key = CREATE_KEY_FN$a(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getRisk.clear(key);
             }
             else {
@@ -4953,23 +5011,22 @@ class StrategyCoreService {
         this.strategySchemaService = inject(TYPES.strategySchemaService);
         this.riskValidationService = inject(TYPES.riskValidationService);
         this.strategyValidationService = inject(TYPES.strategyValidationService);
-        this.methodContextService = inject(TYPES.methodContextService);
         /**
          * Validates strategy and associated risk configuration.
          *
-         * Memoized to avoid redundant validations for the same symbol-strategy pair.
+         * Memoized to avoid redundant validations for the same symbol-strategy-exchange-frame combination.
          * Logs validation activity.
          * @param symbol - Trading pair symbol
-         * @param strategyName - Name of the strategy to validate
+         * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, async (symbol, strategyName) => {
+        this.validate = memoize(([symbol, context]) => `${symbol}:${context.strategyName}:${context.exchangeName}:${context.frameName}`, async (symbol, context) => {
             this.loggerService.log(METHOD_NAME_VALIDATE, {
                 symbol,
-                strategyName,
+                context,
             });
-            const { riskName, riskList } = this.strategySchemaService.get(strategyName);
-            this.strategyValidationService.validate(strategyName, METHOD_NAME_VALIDATE);
+            const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
+            this.strategyValidationService.validate(context.strategyName, METHOD_NAME_VALIDATE);
             riskName && this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE);
             riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_VALIDATE));
         });
@@ -4978,34 +5035,36 @@ class StrategyCoreService {
          * If no active signal exists, returns null.
          * Used internally for monitoring TP/SL and time expiration.
          *
+         * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
-         * @param strategyName - Name of the strategy
+         * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise resolving to pending signal or null
          */
-        this.getPendingSignal = async (backtest, symbol, strategyName) => {
+        this.getPendingSignal = async (backtest, symbol, context) => {
             this.loggerService.log("strategyCoreService getPendingSignal", {
                 symbol,
-                strategyName,
+                context,
             });
-            await this.validate(symbol, strategyName);
-            return await this.strategyConnectionService.getPendingSignal(backtest, symbol, strategyName);
+            await this.validate(symbol, context);
+            return await this.strategyConnectionService.getPendingSignal(backtest, symbol, context);
         };
         /**
          * Retrieves the currently active scheduled signal for the symbol.
          * If no scheduled signal exists, returns null.
          * Used internally for monitoring scheduled signal activation.
          *
+         * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
-         * @param strategyName - Name of the strategy
+         * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise resolving to scheduled signal or null
          */
-        this.getScheduledSignal = async (backtest, symbol, strategyName) => {
+        this.getScheduledSignal = async (backtest, symbol, context) => {
             this.loggerService.log("strategyCoreService getScheduledSignal", {
                 symbol,
-                strategyName,
+                context,
             });
-            await this.validate(symbol, strategyName);
-            return await this.strategyConnectionService.getScheduledSignal(backtest, symbol, strategyName);
+            await this.validate(symbol, context);
+            return await this.strategyConnectionService.getScheduledSignal(backtest, symbol, context);
         };
         /**
          * Checks if the strategy has been stopped.
@@ -5013,18 +5072,19 @@ class StrategyCoreService {
          * Validates strategy existence and delegates to connection service
          * to retrieve the stopped state from the strategy instance.
          *
+         * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
-         * @param strategyName - Name of the strategy
+         * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Promise resolving to true if strategy is stopped, false otherwise
          */
-        this.getStopped = async (backtest, symbol, strategyName) => {
+        this.getStopped = async (backtest, symbol, context) => {
             this.loggerService.log("strategyCoreService getStopped", {
                 symbol,
-                strategyName,
+                context,
                 backtest,
             });
-            await this.validate(symbol, strategyName);
-            return await this.strategyConnectionService.getStopped(backtest, symbol, strategyName);
+            await this.validate(symbol, context);
+            return await this.strategyConnectionService.getStopped(backtest, symbol, context);
         };
         /**
          * Checks signal status at a specific timestamp.
@@ -5035,21 +5095,19 @@ class StrategyCoreService {
          * @param symbol - Trading pair symbol
          * @param when - Timestamp for tick evaluation
          * @param backtest - Whether running in backtest mode
+         * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Discriminated union of tick result (idle, opened, active, closed)
          */
-        this.tick = async (symbol, when, backtest) => {
+        this.tick = async (symbol, when, backtest, context) => {
             this.loggerService.log("strategyCoreService tick", {
                 symbol,
                 when,
                 backtest,
+                context,
             });
-            if (!MethodContextService.hasContext()) {
-                throw new Error("strategyCoreService tick requires a method context");
-            }
-            const strategyName = this.methodContextService.context.strategyName;
-            await this.validate(symbol, strategyName);
+            await this.validate(symbol, context);
             return await ExecutionContextService.runInContext(async () => {
-                return await this.strategyConnectionService.tick(symbol, strategyName);
+                return await this.strategyConnectionService.tick(symbol, context);
             }, {
                 symbol,
                 when,
@@ -5066,22 +5124,20 @@ class StrategyCoreService {
          * @param candles - Array of historical candles to test against
          * @param when - Starting timestamp for backtest
          * @param backtest - Whether running in backtest mode (typically true)
+         * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Closed signal result with PNL
          */
-        this.backtest = async (symbol, candles, when, backtest) => {
+        this.backtest = async (symbol, candles, when, backtest, context) => {
             this.loggerService.log("strategyCoreService backtest", {
                 symbol,
                 candleCount: candles.length,
                 when,
                 backtest,
+                context,
             });
-            if (!MethodContextService.hasContext()) {
-                throw new Error("strategyCoreService backtest requires a method context");
-            }
-            const strategyName = this.methodContextService.context.strategyName;
-            await this.validate(symbol, strategyName);
+            await this.validate(symbol, context);
             return await ExecutionContextService.runInContext(async () => {
-                return await this.strategyConnectionService.backtest(symbol, strategyName, candles);
+                return await this.strategyConnectionService.backtest(symbol, context, candles);
             }, {
                 symbol,
                 when,
@@ -5094,17 +5150,19 @@ class StrategyCoreService {
          * Delegates to StrategyConnectionService.stop() to set internal flag.
          * Does not require execution context.
          *
+         * @param backtest - Whether running in backtest mode
          * @param symbol - Trading pair symbol
-         * @param strategyName - Name of strategy to stop
+         * @param ctx - Context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (backtest, ctx) => {
+        this.stop = async (backtest, symbol, context) => {
             this.loggerService.log("strategyCoreService stop", {
-                ctx,
+                symbol,
+                context,
                 backtest,
             });
-            await this.validate(ctx.symbol, ctx.strategyName);
-            return await this.strategyConnectionService.stop(backtest, ctx);
+            await this.validate(symbol, context);
+            return await this.strategyConnectionService.stop(backtest, symbol, context);
         };
         /**
          * Cancels the scheduled signal without stopping the strategy.
@@ -5114,18 +5172,20 @@ class StrategyCoreService {
          * Does not require execution context.
          *
          * @param backtest - Whether running in backtest mode
-         * @param ctx - Context with symbol and strategyName
+         * @param symbol - Trading pair symbol
+         * @param ctx - Context with strategyName, exchangeName, frameName
          * @param cancelId - Optional cancellation ID for user-initiated cancellations
          * @returns Promise that resolves when scheduled signal is cancelled
          */
-        this.cancel = async (backtest, ctx, cancelId) => {
+        this.cancel = async (backtest, symbol, context, cancelId) => {
             this.loggerService.log("strategyCoreService cancel", {
-                ctx,
+                symbol,
+                context,
                 backtest,
                 cancelId,
             });
-            await this.validate(ctx.symbol, ctx.strategyName);
-            return await this.strategyConnectionService.cancel(backtest, ctx, cancelId);
+            await this.validate(symbol, context);
+            return await this.strategyConnectionService.cancel(backtest, symbol, context, cancelId);
         };
         /**
          * Clears the memoized ClientStrategy instance from cache.
@@ -5133,16 +5193,20 @@ class StrategyCoreService {
          * Delegates to StrategyConnectionService.clear() to remove strategy from cache.
          * Forces re-initialization of strategy on next operation.
          *
-         * @param ctx - Optional context with symbol and strategyName (clears all if not provided)
+         * @param payload - Optional payload with symbol, context and backtest flag (clears all if not provided)
          */
-        this.clear = async (backtest, ctx) => {
+        this.clear = async (payload) => {
             this.loggerService.log("strategyCoreService clear", {
-                ctx,
+                payload,
             });
-            if (ctx) {
-                await this.validate(ctx.symbol, ctx.strategyName);
+            if (payload) {
+                await this.validate(payload.symbol, {
+                    strategyName: payload.strategyName,
+                    exchangeName: payload.exchangeName,
+                    frameName: payload.frameName
+                });
             }
-            return await this.strategyConnectionService.clear(backtest, ctx);
+            return await this.strategyConnectionService.clear(payload);
         };
     }
 }
@@ -5223,76 +5287,74 @@ class RiskGlobalService {
         this.riskValidationService = inject(TYPES.riskValidationService);
         /**
          * Validates risk configuration.
-         * Memoized to avoid redundant validations for the same risk instance.
+         * Memoized to avoid redundant validations for the same risk-exchange-frame combination.
          * Logs validation activity.
-         * @param riskName - Name of the risk instance to validate
+         * @param payload - Payload with riskName, exchangeName and frameName
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([riskName]) => `${riskName}`, async (riskName) => {
+        this.validate = memoize(([payload]) => `${payload.riskName}:${payload.exchangeName}:${payload.frameName}`, async (payload) => {
             this.loggerService.log("riskGlobalService validate", {
-                riskName,
+                payload,
             });
-            this.riskValidationService.validate(riskName, "riskGlobalService validate");
+            this.riskValidationService.validate(payload.riskName, "riskGlobalService validate");
         });
         /**
          * Checks if a signal should be allowed based on risk limits.
          *
          * @param params - Risk check arguments (portfolio state, position details)
-         * @param context - Execution context with risk name
+         * @param payload - Execution payload with risk name, exchangeName, frameName and backtest mode
          * @returns Promise resolving to risk check result
          */
-        this.checkSignal = async (params, context) => {
+        this.checkSignal = async (params, payload) => {
             this.loggerService.log("riskGlobalService checkSignal", {
                 symbol: params.symbol,
-                context,
+                payload,
             });
-            await this.validate(context.riskName);
-            return await this.riskConnectionService.checkSignal(params, context);
+            await this.validate(payload);
+            return await this.riskConnectionService.checkSignal(params, payload);
         };
         /**
          * Registers an opened signal with the risk management system.
          *
          * @param symbol - Trading pair symbol
-         * @param context - Context information (strategyName, riskName)
+         * @param payload - Payload information (strategyName, riskName, exchangeName, frameName, backtest)
          */
-        this.addSignal = async (symbol, context) => {
+        this.addSignal = async (symbol, payload) => {
             this.loggerService.log("riskGlobalService addSignal", {
                 symbol,
-                context,
+                payload,
             });
-            await this.validate(context.riskName);
-            await this.riskConnectionService.addSignal(symbol, context);
+            await this.validate(payload);
+            await this.riskConnectionService.addSignal(symbol, payload);
         };
         /**
          * Removes a closed signal from the risk management system.
          *
          * @param symbol - Trading pair symbol
-         * @param context - Context information (strategyName, riskName)
+         * @param payload - Payload information (strategyName, riskName, exchangeName, frameName, backtest)
          */
-        this.removeSignal = async (symbol, context) => {
+        this.removeSignal = async (symbol, payload) => {
             this.loggerService.log("riskGlobalService removeSignal", {
                 symbol,
-                context,
+                payload,
             });
-            await this.validate(context.riskName);
-            await this.riskConnectionService.removeSignal(symbol, context);
+            await this.validate(payload);
+            await this.riskConnectionService.removeSignal(symbol, payload);
         };
         /**
          * Clears risk data.
-         * If ctx is provided, clears data for that specific risk instance.
-         * If no ctx is provided, clears all risk data.
-         * @param backtest - Whether running in backtest mode
-         * @param ctx - Optional context with riskName (clears all if not provided)
+         * If payload is provided, clears data for that specific risk instance.
+         * If no payload is provided, clears all risk data.
+         * @param payload - Optional payload with riskName, exchangeName, frameName, backtest (clears all if not provided)
          */
-        this.clear = async (backtest, ctx) => {
+        this.clear = async (payload) => {
             this.loggerService.log("riskGlobalService clear", {
-                ctx,
-                backtest,
+                payload,
             });
-            if (ctx) {
-                await this.validate(ctx.riskName);
+            if (payload) {
+                await this.validate(payload);
             }
-            return await this.riskConnectionService.clear(backtest, ctx);
+            return await this.riskConnectionService.clear(payload);
         };
     }
 }
@@ -5843,7 +5905,11 @@ class BacktestLogicPrivateService {
                 });
             }
             // Check if strategy should stop before processing next frame
-            if (await this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName)) {
+            if (await this.strategyCoreService.getStopped(true, symbol, {
+                strategyName: this.methodContextService.context.strategyName,
+                exchangeName: this.methodContextService.context.exchangeName,
+                frameName: this.methodContextService.context.frameName,
+            })) {
                 this.loggerService.info("backtestLogicPrivateService stopped by user request (before tick)", {
                     symbol,
                     when: when.toISOString(),
@@ -5854,7 +5920,11 @@ class BacktestLogicPrivateService {
             }
             let result;
             try {
-                result = await this.strategyCoreService.tick(symbol, when, true);
+                result = await this.strategyCoreService.tick(symbol, when, true, {
+                    strategyName: this.methodContextService.context.strategyName,
+                    exchangeName: this.methodContextService.context.exchangeName,
+                    frameName: this.methodContextService.context.frameName,
+                });
             }
             catch (error) {
                 console.warn(`backtestLogicPrivateService tick failed, skipping timeframe when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
@@ -5868,7 +5938,11 @@ class BacktestLogicPrivateService {
                 continue;
             }
             // Check if strategy should stop when idle (no active signal)
-            if (await and(Promise.resolve(result.action === "idle"), this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName))) {
+            if (await and(Promise.resolve(result.action === "idle"), this.strategyCoreService.getStopped(true, symbol, {
+                strategyName: this.methodContextService.context.strategyName,
+                exchangeName: this.methodContextService.context.exchangeName,
+                frameName: this.methodContextService.context.frameName,
+            }))) {
                 this.loggerService.info("backtestLogicPrivateService stopped by user request (idle state)", {
                     symbol,
                     when: when.toISOString(),
@@ -5927,7 +6001,11 @@ class BacktestLogicPrivateService {
                 // и если активируется - продолжит с TP/SL мониторингом
                 let backtestResult;
                 try {
-                    backtestResult = await this.strategyCoreService.backtest(symbol, candles, when, true);
+                    backtestResult = await this.strategyCoreService.backtest(symbol, candles, when, true, {
+                        strategyName: this.methodContextService.context.strategyName,
+                        exchangeName: this.methodContextService.context.exchangeName,
+                        frameName: this.methodContextService.context.frameName,
+                    });
                 }
                 catch (error) {
                     console.warn(`backtestLogicPrivateService backtest failed for scheduled signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
@@ -5959,6 +6037,7 @@ class BacktestLogicPrivateService {
                     duration: signalEndTime - signalStartTime,
                     strategyName: this.methodContextService.context.strategyName,
                     exchangeName: this.methodContextService.context.exchangeName,
+                    frameName: this.methodContextService.context.frameName,
                     symbol,
                     backtest: true,
                 });
@@ -5970,7 +6049,11 @@ class BacktestLogicPrivateService {
                 }
                 yield backtestResult;
                 // Check if strategy should stop after signal is closed
-                if (await this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(true, symbol, {
+                    strategyName: this.methodContextService.context.strategyName,
+                    exchangeName: this.methodContextService.context.exchangeName,
+                    frameName: this.methodContextService.context.frameName,
+                })) {
                     this.loggerService.info("backtestLogicPrivateService stopped by user request (after scheduled signal closed)", {
                         symbol,
                         signalId: backtestResult.signal.id,
@@ -6024,7 +6107,11 @@ class BacktestLogicPrivateService {
                 // Вызываем backtest - всегда возвращает closed
                 let backtestResult;
                 try {
-                    backtestResult = await this.strategyCoreService.backtest(symbol, candles, when, true);
+                    backtestResult = await this.strategyCoreService.backtest(symbol, candles, when, true, {
+                        strategyName: this.methodContextService.context.strategyName,
+                        exchangeName: this.methodContextService.context.exchangeName,
+                        frameName: this.methodContextService.context.frameName,
+                    });
                 }
                 catch (error) {
                     console.warn(`backtestLogicPrivateService backtest failed for opened signal when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
@@ -6052,6 +6139,7 @@ class BacktestLogicPrivateService {
                     duration: signalEndTime - signalStartTime,
                     strategyName: this.methodContextService.context.strategyName,
                     exchangeName: this.methodContextService.context.exchangeName,
+                    frameName: this.methodContextService.context.frameName,
                     symbol,
                     backtest: true,
                 });
@@ -6063,7 +6151,11 @@ class BacktestLogicPrivateService {
                 }
                 yield backtestResult;
                 // Check if strategy should stop after signal is closed
-                if (await this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(true, symbol, {
+                    strategyName: this.methodContextService.context.strategyName,
+                    exchangeName: this.methodContextService.context.exchangeName,
+                    frameName: this.methodContextService.context.frameName,
+                })) {
                     this.loggerService.info("backtestLogicPrivateService stopped by user request (after signal closed)", {
                         symbol,
                         signalId: backtestResult.signal.id,
@@ -6083,6 +6175,7 @@ class BacktestLogicPrivateService {
                 duration: timeframeEndTime - timeframeStartTime,
                 strategyName: this.methodContextService.context.strategyName,
                 exchangeName: this.methodContextService.context.exchangeName,
+                frameName: this.methodContextService.context.frameName,
                 symbol,
                 backtest: true,
             });
@@ -6110,6 +6203,7 @@ class BacktestLogicPrivateService {
             duration: backtestEndTime - backtestStartTime,
             strategyName: this.methodContextService.context.strategyName,
             exchangeName: this.methodContextService.context.exchangeName,
+            frameName: this.methodContextService.context.frameName,
             symbol,
             backtest: true,
         });
@@ -6172,7 +6266,11 @@ class LiveLogicPrivateService {
             const when = new Date();
             let result;
             try {
-                result = await this.strategyCoreService.tick(symbol, when, false);
+                result = await this.strategyCoreService.tick(symbol, when, false, {
+                    strategyName: this.methodContextService.context.strategyName,
+                    exchangeName: this.methodContextService.context.exchangeName,
+                    frameName: this.methodContextService.context.frameName,
+                });
             }
             catch (error) {
                 console.warn(`backtestLogicPrivateService tick failed when=${when.toISOString()} symbol=${symbol} strategyName=${this.methodContextService.context.strategyName} exchangeName=${this.methodContextService.context.exchangeName}`);
@@ -6200,13 +6298,18 @@ class LiveLogicPrivateService {
                 duration: tickEndTime - tickStartTime,
                 strategyName: this.methodContextService.context.strategyName,
                 exchangeName: this.methodContextService.context.exchangeName,
+                frameName: this.methodContextService.context.frameName,
                 symbol,
                 backtest: false,
             });
             previousEventTimestamp = currentTimestamp;
             // Check if strategy should stop when idle (no active signal)
             if (result.action === "idle") {
-                if (await and(Promise.resolve(true), this.strategyCoreService.getStopped(false, symbol, this.methodContextService.context.strategyName))) {
+                if (await and(Promise.resolve(true), this.strategyCoreService.getStopped(false, symbol, {
+                    strategyName: this.methodContextService.context.strategyName,
+                    exchangeName: this.methodContextService.context.exchangeName,
+                    frameName: this.methodContextService.context.frameName,
+                }))) {
                     this.loggerService.info("liveLogicPrivateService stopped by user request (idle state)", {
                         symbol,
                         when: when.toISOString(),
@@ -6228,7 +6331,11 @@ class LiveLogicPrivateService {
             yield result;
             // Check if strategy should stop after signal is closed
             if (result.action === "closed") {
-                if (await this.strategyCoreService.getStopped(false, symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(false, symbol, {
+                    strategyName: this.methodContextService.context.strategyName,
+                    exchangeName: this.methodContextService.context.exchangeName,
+                    frameName: this.methodContextService.context.frameName,
+                })) {
                     this.loggerService.info("liveLogicPrivateService stopped by user request (after signal closed)", {
                         symbol,
                         signalId: result.signal.id,
@@ -6360,7 +6467,7 @@ class WalkerLogicPrivateService {
                     symbol,
                 });
                 // Get statistics from BacktestMarkdownService
-                const stats = await this.backtestMarkdownService.getData(symbol, strategyName, true);
+                const stats = await this.backtestMarkdownService.getData(symbol, strategyName, context.exchangeName, context.frameName, true);
                 // Extract metric value
                 const value = stats[metric];
                 const metricValue = value !== null &&
@@ -6424,7 +6531,7 @@ class WalkerLogicPrivateService {
             bestStrategy,
             bestMetric,
             bestStats: bestStrategy !== null
-                ? await this.backtestMarkdownService.getData(symbol, bestStrategy, true)
+                ? await this.backtestMarkdownService.getData(symbol, bestStrategy, context.exchangeName, context.frameName, true)
                 : null,
         };
         // Call onComplete callback if provided with final best results
@@ -7787,13 +7894,21 @@ const DEFAULT_COLUMNS = Object.freeze({ ...COLUMN_CONFIG });
 
 /**
  * Creates a unique key for memoizing ReportStorage instances.
- * Key format: "symbol:strategyName:backtest" or "symbol:strategyName:live"
+ * Key format: "symbol:strategyName:exchangeName:frameName:backtest" or "symbol:strategyName:exchangeName:live"
  * @param symbol - Trading pair symbol
  * @param strategyName - Name of the strategy
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$9 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$9 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
 /**
  * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
  *
@@ -7999,17 +8114,17 @@ class BacktestMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
-         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
+         * 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, backtest]) => CREATE_KEY_FN$9(symbol, strategyName, backtest), () => new ReportStorage$5());
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$9(symbol, strategyName, exchangeName, frameName, backtest), () => new ReportStorage$5());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
          *
          * Only processes closed signals - opened signals are ignored.
          *
-         * @param data - Tick result from strategy execution (opened or closed)
+         * @param data - Tick result from strategy execution (opened or closed) with frameName wrapper
          *
          * @example
          * ```typescript
@@ -8029,7 +8144,7 @@ class BacktestMarkdownService {
             if (data.action !== "closed") {
                 return;
             }
-            const storage = this.getStorage(data.symbol, data.strategyName, true);
+            const storage = this.getStorage(data.symbol, data.strategyName, data.exchangeName, data.frameName, true);
             storage.addSignal(data);
         };
         /**
@@ -8038,23 +8153,27 @@ class BacktestMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new BacktestMarkdownService();
-         * const stats = await service.getData("BTCUSDT", "my-strategy", true);
+         * const stats = await service.getData("BTCUSDT", "my-strategy", "binance", "1h", true);
          * console.log(stats.sharpeRatio, stats.winRate);
          * ```
          */
-        this.getData = async (symbol, strategyName, backtest) => {
+        this.getData = async (symbol, strategyName, exchangeName, frameName, backtest) => {
             this.loggerService.log("backtestMarkdownService getData", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getData();
         };
         /**
@@ -8063,6 +8182,8 @@ class BacktestMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all closed signals
@@ -8070,17 +8191,19 @@ class BacktestMarkdownService {
          * @example
          * ```typescript
          * const service = new BacktestMarkdownService();
-         * const markdown = await service.getReport("BTCUSDT", "my-strategy", true);
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy", "binance", "1h", true);
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, backtest, columns = COLUMN_CONFIG.backtest_columns) => {
+        this.getReport = async (symbol, strategyName, exchangeName, frameName, backtest, columns = COLUMN_CONFIG.backtest_columns) => {
             this.loggerService.log("backtestMarkdownService getReport", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getReport(strategyName, columns);
         };
         /**
@@ -8090,6 +8213,8 @@ class BacktestMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @param path - Directory path to save report (default: "./dump/backtest")
          * @param columns - Column configuration for formatting the table
@@ -8099,48 +8224,48 @@ class BacktestMarkdownService {
          * const service = new BacktestMarkdownService();
          *
          * // Save to default path: ./dump/backtest/my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", true);
+         * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", true);
          *
          * // Save to custom path: ./custom/path/my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", true, "./custom/path");
+         * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", true, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, backtest, path = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) => {
+        this.dump = async (symbol, strategyName, exchangeName, frameName, backtest, path = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) => {
             this.loggerService.log("backtestMarkdownService dump", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
                 path,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated signal data from storage.
-         * If ctx is provided, clears only that specific symbol-strategy-backtest triple's data.
+         * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
          * If nothing is provided, clears all data.
          *
-         * @param backtest - Backtest mode flag
-         * @param ctx - Optional context with symbol and strategyName
+         * @param payload - Optional payload with symbol, strategyName, exchangeName, frameName, backtest
          *
          * @example
          * ```typescript
          * const service = new BacktestMarkdownService();
          *
-         * // Clear specific symbol-strategy-backtest triple
-         * await service.clear(true, { symbol: "BTCUSDT", strategyName: "my-strategy" });
+         * // Clear specific combination
+         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy", exchangeName: "binance", frameName: "1h", backtest: true });
          *
          * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (backtest, ctx) => {
+        this.clear = async (payload) => {
             this.loggerService.log("backtestMarkdownService clear", {
-                backtest,
-                ctx,
+                payload,
             });
-            if (ctx) {
-                const key = CREATE_KEY_FN$9(ctx.symbol, ctx.strategyName, backtest);
+            if (payload) {
+                const key = CREATE_KEY_FN$9(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -8167,13 +8292,21 @@ class BacktestMarkdownService {
 
 /**
  * Creates a unique key for memoizing ReportStorage instances.
- * Key format: "symbol:strategyName:backtest" or "symbol:strategyName:live"
+ * Key format: "symbol:strategyName:exchangeName:frameName:backtest" or "symbol:strategyName:exchangeName:live"
  * @param symbol - Trading pair symbol
  * @param strategyName - Name of the strategy
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$8 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$8 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
 /**
  * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
  *
@@ -8500,17 +8633,17 @@ class LiveMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
-         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
+         * 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, backtest]) => CREATE_KEY_FN$8(symbol, strategyName, backtest), () => new ReportStorage$4());
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$8(symbol, strategyName, exchangeName, frameName, backtest), () => new ReportStorage$4());
         /**
          * Processes tick events and accumulates all event types.
          * Should be called from IStrategyCallbacks.onTick.
          *
          * Processes all event types: idle, opened, active, closed.
          *
-         * @param data - Tick result from strategy execution
+         * @param data - Tick result from strategy execution with frameName wrapper
          *
          * @example
          * ```typescript
@@ -8529,7 +8662,7 @@ class LiveMarkdownService {
             this.loggerService.log("liveMarkdownService tick", {
                 data,
             });
-            const storage = this.getStorage(data.symbol, data.strategyName, false);
+            const storage = this.getStorage(data.symbol, data.strategyName, data.exchangeName, data.frameName, false);
             if (data.action === "idle") {
                 storage.addIdleEvent(data.currentPrice);
             }
@@ -8549,23 +8682,27 @@ class LiveMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new LiveMarkdownService();
-         * const stats = await service.getData("BTCUSDT", "my-strategy", false);
+         * const stats = await service.getData("BTCUSDT", "my-strategy", "binance", "1h", false);
          * console.log(stats.sharpeRatio, stats.winRate);
          * ```
          */
-        this.getData = async (symbol, strategyName, backtest) => {
+        this.getData = async (symbol, strategyName, exchangeName, frameName, backtest) => {
             this.loggerService.log("liveMarkdownService getData", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getData();
         };
         /**
@@ -8574,6 +8711,8 @@ class LiveMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
@@ -8581,17 +8720,19 @@ class LiveMarkdownService {
          * @example
          * ```typescript
          * const service = new LiveMarkdownService();
-         * const markdown = await service.getReport("BTCUSDT", "my-strategy", false);
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy", "binance", "1h", false);
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, backtest, columns = COLUMN_CONFIG.live_columns) => {
+        this.getReport = async (symbol, strategyName, exchangeName, frameName, backtest, columns = COLUMN_CONFIG.live_columns) => {
             this.loggerService.log("liveMarkdownService getReport", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getReport(strategyName, columns);
         };
         /**
@@ -8601,6 +8742,8 @@ class LiveMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @param path - Directory path to save report (default: "./dump/live")
          * @param columns - Column configuration for formatting the table
@@ -8610,48 +8753,48 @@ class LiveMarkdownService {
          * const service = new LiveMarkdownService();
          *
          * // Save to default path: ./dump/live/my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", false);
+         * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false);
          *
          * // Save to custom path: ./custom/path/my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", false, "./custom/path");
+         * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, backtest, path = "./dump/live", columns = COLUMN_CONFIG.live_columns) => {
+        this.dump = async (symbol, strategyName, exchangeName, frameName, backtest, path = "./dump/live", columns = COLUMN_CONFIG.live_columns) => {
             this.loggerService.log("liveMarkdownService dump", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
                 path,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
-         * If ctx is provided, clears only that specific symbol-strategy-backtest triple's data.
+         * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
          * If nothing is provided, clears all data.
          *
-         * @param backtest - Backtest mode flag
-         * @param ctx - Optional context with symbol and strategyName
+         * @param payload - Optional payload with symbol, strategyName, exchangeName, frameName, backtest
          *
          * @example
          * ```typescript
          * const service = new LiveMarkdownService();
          *
-         * // Clear specific symbol-strategy-backtest triple
-         * await service.clear(false, { symbol: "BTCUSDT", strategyName: "my-strategy" });
+         * // Clear specific combination
+         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy", exchangeName: "binance", frameName: "1h", backtest: false });
          *
          * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (backtest, ctx) => {
+        this.clear = async (payload) => {
             this.loggerService.log("liveMarkdownService clear", {
-                backtest,
-                ctx,
+                payload,
             });
-            if (ctx) {
-                const key = CREATE_KEY_FN$8(ctx.symbol, ctx.strategyName, backtest);
+            if (payload) {
+                const key = CREATE_KEY_FN$8(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -8678,13 +8821,21 @@ class LiveMarkdownService {
 
 /**
  * Creates a unique key for memoizing ReportStorage instances.
- * Key format: "symbol:strategyName:backtest" or "symbol:strategyName:live"
+ * Key format: "symbol:strategyName:exchangeName:frameName:backtest" or "symbol:strategyName:exchangeName:live"
  * @param symbol - Trading pair symbol
  * @param strategyName - Name of the strategy
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$7 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$7 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
 /** Maximum number of events to store in schedule reports */
 const MAX_EVENTS$4 = 250;
 /**
@@ -8917,17 +9068,17 @@ class ScheduleMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
-         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
+         * 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, backtest]) => CREATE_KEY_FN$7(symbol, strategyName, backtest), () => new ReportStorage$3());
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$7(symbol, strategyName, exchangeName, frameName, backtest), () => new ReportStorage$3());
         /**
          * Processes tick events and accumulates scheduled/opened/cancelled events.
          * Should be called from signalEmitter subscription.
          *
          * Processes only scheduled, opened and cancelled event types.
          *
-         * @param data - Tick result from strategy execution
+         * @param data - Tick result from strategy execution with frameName wrapper
          *
          * @example
          * ```typescript
@@ -8939,7 +9090,7 @@ class ScheduleMarkdownService {
             this.loggerService.log("scheduleMarkdownService tick", {
                 data,
             });
-            const storage = this.getStorage(data.symbol, data.strategyName, data.backtest);
+            const storage = this.getStorage(data.symbol, data.strategyName, data.exchangeName, data.frameName, data.backtest);
             if (data.action === "scheduled") {
                 storage.addScheduledEvent(data);
             }
@@ -8960,23 +9111,27 @@ class ScheduleMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new ScheduleMarkdownService();
-         * const stats = await service.getData("BTCUSDT", "my-strategy", false);
+         * const stats = await service.getData("BTCUSDT", "my-strategy", "binance", "1h", false);
          * console.log(stats.cancellationRate, stats.avgWaitTime);
          * ```
          */
-        this.getData = async (symbol, strategyName, backtest) => {
+        this.getData = async (symbol, strategyName, exchangeName, frameName, backtest) => {
             this.loggerService.log("scheduleMarkdownService getData", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getData();
         };
         /**
@@ -8985,6 +9140,8 @@ class ScheduleMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
@@ -8992,17 +9149,19 @@ class ScheduleMarkdownService {
          * @example
          * ```typescript
          * const service = new ScheduleMarkdownService();
-         * const markdown = await service.getReport("BTCUSDT", "my-strategy", false);
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy", "binance", "1h", false);
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, backtest, columns = COLUMN_CONFIG.schedule_columns) => {
+        this.getReport = async (symbol, strategyName, exchangeName, frameName, backtest, columns = COLUMN_CONFIG.schedule_columns) => {
             this.loggerService.log("scheduleMarkdownService getReport", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getReport(strategyName, columns);
         };
         /**
@@ -9012,6 +9171,8 @@ class ScheduleMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @param path - Directory path to save report (default: "./dump/schedule")
          * @param columns - Column configuration for formatting the table
@@ -9021,48 +9182,48 @@ class ScheduleMarkdownService {
          * const service = new ScheduleMarkdownService();
          *
          * // Save to default path: ./dump/schedule/my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", false);
+         * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false);
          *
          * // Save to custom path: ./custom/path/my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", false, "./custom/path");
+         * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, backtest, path = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) => {
+        this.dump = async (symbol, strategyName, exchangeName, frameName, backtest, path = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) => {
             this.loggerService.log("scheduleMarkdownService dump", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
                 path,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
-         * If ctx is provided, clears only that specific symbol-strategy-backtest triple's data.
+         * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
          * If nothing is provided, clears all data.
          *
-         * @param backtest - Backtest mode flag
-         * @param ctx - Optional context with symbol and strategyName
+         * @param payload - Optional payload with symbol, strategyName, exchangeName, frameName, backtest
          *
          * @example
          * ```typescript
          * const service = new ScheduleMarkdownService();
          *
-         * // Clear specific symbol-strategy-backtest triple
-         * await service.clear(false, { symbol: "BTCUSDT", strategyName: "my-strategy" });
+         * // Clear specific combination
+         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy", exchangeName: "binance", frameName: "1h", backtest: false });
          *
          * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (backtest, ctx) => {
+        this.clear = async (payload) => {
             this.loggerService.log("scheduleMarkdownService clear", {
-                backtest,
-                ctx,
+                payload,
             });
-            if (ctx) {
-                const key = CREATE_KEY_FN$7(ctx.symbol, ctx.strategyName, backtest);
+            if (payload) {
+                const key = CREATE_KEY_FN$7(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -9089,13 +9250,21 @@ class ScheduleMarkdownService {
 
 /**
  * Creates a unique key for memoizing PerformanceStorage instances.
- * Key format: "symbol:strategyName:backtest" or "symbol:strategyName:live"
+ * Key format: "symbol:strategyName:exchangeName:frameName:backtest" or "symbol:strategyName:exchangeName:live"
  * @param symbol - Trading pair symbol
  * @param strategyName - Name of the strategy
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$6 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$6 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
 /**
  * Calculates percentile value from sorted array.
  */
@@ -9310,10 +9479,10 @@ class PerformanceMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create PerformanceStorage for a symbol-strategy-backtest triple.
-         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
+         * 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, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, backtest), () => new PerformanceStorage());
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$6(symbol, strategyName, exchangeName, frameName, backtest), () => new PerformanceStorage());
         /**
          * Processes performance events and accumulates metrics.
          * Should be called from performance tracking code.
@@ -9326,7 +9495,8 @@ class PerformanceMarkdownService {
             });
             const symbol = event.symbol || "global";
             const strategyName = event.strategyName || "global";
-            const storage = this.getStorage(symbol, strategyName, event.backtest);
+            const exchangeName = event.exchangeName || "global";
+            const storage = this.getStorage(symbol, strategyName, exchangeName, event.frameName, event.backtest);
             storage.addEvent(event);
         };
         /**
@@ -9334,24 +9504,28 @@ class PerformanceMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @returns Performance statistics with aggregated metrics
          *
          * @example
          * ```typescript
-         * const stats = await performanceService.getData("BTCUSDT", "my-strategy", false);
+         * const stats = await performanceService.getData("BTCUSDT", "my-strategy", "binance", "1h", false);
          * console.log("Total time:", stats.totalDuration);
          * console.log("Slowest operation:", Object.values(stats.metricStats)
          *   .sort((a, b) => b.avgDuration - a.avgDuration)[0]);
          * ```
          */
-        this.getData = async (symbol, strategyName, backtest) => {
+        this.getData = async (symbol, strategyName, exchangeName, frameName, backtest) => {
             this.loggerService.log("performanceMarkdownService getData", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getData(strategyName);
         };
         /**
@@ -9359,23 +9533,27 @@ class PerformanceMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string
          *
          * @example
          * ```typescript
-         * const markdown = await performanceService.getReport("BTCUSDT", "my-strategy", false);
+         * const markdown = await performanceService.getReport("BTCUSDT", "my-strategy", "binance", "1h", false);
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, backtest, columns = COLUMN_CONFIG.performance_columns) => {
+        this.getReport = async (symbol, strategyName, exchangeName, frameName, backtest, columns = COLUMN_CONFIG.performance_columns) => {
             this.loggerService.log("performanceMarkdownService getReport", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getReport(strategyName, columns);
         };
         /**
@@ -9383,6 +9561,8 @@ class PerformanceMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @param path - Directory path to save report
          * @param columns - Column configuration for formatting the table
@@ -9390,35 +9570,35 @@ class PerformanceMarkdownService {
          * @example
          * ```typescript
          * // Save to default path: ./dump/performance/my-strategy.md
-         * await performanceService.dump("BTCUSDT", "my-strategy", false);
+         * await performanceService.dump("BTCUSDT", "my-strategy", "binance", "1h", false);
          *
          * // Save to custom path
-         * await performanceService.dump("BTCUSDT", "my-strategy", false, "./custom/path");
+         * await performanceService.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, backtest, path = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) => {
+        this.dump = async (symbol, strategyName, exchangeName, frameName, backtest, path = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) => {
             this.loggerService.log("performanceMarkdownService dump", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
                 path,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated performance data from storage.
          *
-         * @param backtest - Backtest mode flag
-         * @param ctx - Optional context with symbol and strategyName
+         * @param payload - Optional payload with symbol, strategyName, exchangeName, frameName, backtest
          */
-        this.clear = async (backtest, ctx) => {
+        this.clear = async (payload) => {
             this.loggerService.log("performanceMarkdownService clear", {
-                backtest,
-                ctx,
+                payload,
             });
-            if (ctx) {
-                const key = CREATE_KEY_FN$6(ctx.symbol, ctx.strategyName, backtest);
+            if (payload) {
+                const key = CREATE_KEY_FN$6(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -9847,12 +10027,19 @@ class WalkerMarkdownService {
 
 /**
  * Creates a unique key for memoizing HeatmapStorage instances.
- * Key format: "strategyName:backtest" or "strategyName:live"
- * @param strategyName - Name of the strategy
+ * Key format: "exchangeName:frameName:backtest" or "exchangeName:live"
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$5 = (strategyName, backtest) => `${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$5 = (exchangeName, frameName, backtest) => {
+    const parts = [exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
 const HEATMAP_METHOD_NAME_GET_DATA = "HeatMarkdownService.getData";
 const HEATMAP_METHOD_NAME_GET_REPORT = "HeatMarkdownService.getReport";
 const HEATMAP_METHOD_NAME_DUMP = "HeatMarkdownService.dump";
@@ -10193,10 +10380,10 @@ class HeatMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create HeatmapStorage for a strategy and backtest mode.
-         * Each strategy + backtest mode combination gets its own isolated heatmap storage instance.
+         * 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(([strategyName, backtest]) => CREATE_KEY_FN$5(strategyName, backtest), () => new HeatmapStorage());
+        this.getStorage = memoize(([exchangeName, frameName, backtest]) => CREATE_KEY_FN$5(exchangeName, frameName, backtest), () => new HeatmapStorage());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from signal emitter subscription.
@@ -10212,20 +10399,21 @@ class HeatMarkdownService {
             if (data.action !== "closed") {
                 return;
             }
-            const storage = this.getStorage(data.strategyName, data.backtest);
+            const storage = this.getStorage(data.exchangeName, data.frameName, data.backtest);
             storage.addSignal(data);
         };
         /**
-         * Gets aggregated portfolio heatmap statistics for a strategy.
+         * Gets aggregated portfolio heatmap statistics.
          *
-         * @param strategyName - Strategy name to get heatmap data for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @returns Promise resolving to heatmap statistics with per-symbol and portfolio-wide metrics
          *
          * @example
          * ```typescript
          * const service = new HeatMarkdownService();
-         * const stats = await service.getData("my-strategy", true);
+         * const stats = await service.getData("binance", "frame1", true);
          *
          * console.log(`Total symbols: ${stats.totalSymbols}`);
          * console.log(`Portfolio PNL: ${stats.portfolioTotalPnl}%`);
@@ -10235,18 +10423,21 @@ class HeatMarkdownService {
          * });
          * ```
          */
-        this.getData = async (strategyName, backtest) => {
+        this.getData = async (exchangeName, frameName, backtest) => {
             this.loggerService.log(HEATMAP_METHOD_NAME_GET_DATA, {
-                strategyName,
+                exchangeName,
+                frameName,
                 backtest,
             });
-            const storage = this.getStorage(strategyName, backtest);
+            const storage = this.getStorage(exchangeName, frameName, backtest);
             return storage.getData();
         };
         /**
-         * Generates markdown report with portfolio heatmap table for a strategy.
+         * Generates markdown report with portfolio heatmap table.
          *
-         * @param strategyName - Strategy name to generate heatmap report for
+         * @param strategyName - Strategy name for report title
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @param columns - Column configuration for formatting the table
          * @returns Promise resolving to markdown formatted report string
@@ -10254,7 +10445,7 @@ class HeatMarkdownService {
          * @example
          * ```typescript
          * const service = new HeatMarkdownService();
-         * const markdown = await service.getReport("my-strategy", true);
+         * const markdown = await service.getReport("my-strategy", "binance", "frame1", true);
          * console.log(markdown);
          * // Output:
          * // # Portfolio Heatmap: my-strategy
@@ -10268,21 +10459,25 @@ class HeatMarkdownService {
          * // ...
          * ```
          */
-        this.getReport = async (strategyName, backtest, columns = COLUMN_CONFIG.heat_columns) => {
+        this.getReport = async (strategyName, exchangeName, frameName, backtest, columns = COLUMN_CONFIG.heat_columns) => {
             this.loggerService.log(HEATMAP_METHOD_NAME_GET_REPORT, {
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
             });
-            const storage = this.getStorage(strategyName, backtest);
+            const storage = this.getStorage(exchangeName, frameName, backtest);
             return storage.getReport(strategyName, columns);
         };
         /**
-         * Saves heatmap report to disk for a strategy.
+         * Saves heatmap report to disk.
          *
          * Creates directory if it doesn't exist.
          * Default filename: {strategyName}.md
          *
-         * @param strategyName - Strategy name to save heatmap report for
+         * @param strategyName - Strategy name for report filename
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @param path - Optional directory path to save report (default: "./dump/heatmap")
          * @param columns - Column configuration for formatting the table
@@ -10292,47 +10487,47 @@ class HeatMarkdownService {
          * const service = new HeatMarkdownService();
          *
          * // Save to default path: ./dump/heatmap/my-strategy.md
-         * await service.dump("my-strategy", true);
+         * await service.dump("my-strategy", "binance", "frame1", true);
          *
          * // Save to custom path: ./reports/my-strategy.md
-         * await service.dump("my-strategy", true, "./reports");
+         * await service.dump("my-strategy", "binance", "frame1", true, "./reports");
          * ```
          */
-        this.dump = async (strategyName, backtest, path = "./dump/heatmap", columns = COLUMN_CONFIG.heat_columns) => {
+        this.dump = async (strategyName, exchangeName, frameName, backtest, path = "./dump/heatmap", columns = COLUMN_CONFIG.heat_columns) => {
             this.loggerService.log(HEATMAP_METHOD_NAME_DUMP, {
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
                 path,
             });
-            const storage = this.getStorage(strategyName, backtest);
+            const storage = this.getStorage(exchangeName, frameName, backtest);
             await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated heatmap data from storage.
-         * If ctx is provided, clears only that strategy+backtest combination's data.
-         * If ctx is omitted, clears all data.
+         * If payload is provided, clears only that exchangeName+frameName+backtest combination's data.
+         * If payload is omitted, clears all data.
          *
-         * @param backtest - Backtest mode flag
-         * @param ctx - Optional context with strategyName to clear specific data
+         * @param payload - Optional payload with exchangeName, frameName, backtest to clear specific data
          *
          * @example
          * ```typescript
          * const service = new HeatMarkdownService();
          *
-         * // Clear specific strategy+backtest data
-         * await service.clear(true, { strategyName: "my-strategy" });
+         * // Clear specific exchange+frame+backtest data
+         * await service.clear({ exchangeName: "binance", frameName: "frame1", backtest: true });
          *
          * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (backtest, ctx) => {
+        this.clear = async (payload) => {
             this.loggerService.log(HEATMAP_METHOD_NAME_CLEAR, {
-                backtest,
-                ctx,
+                payload,
             });
-            if (ctx) {
-                const key = CREATE_KEY_FN$5(ctx.strategyName, backtest);
+            if (payload) {
+                const key = CREATE_KEY_FN$5(payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -12190,7 +12385,7 @@ const HANDLE_PROFIT_FN = async (symbol, data, currentPrice, revenuePercent, back
                 revenuePercent,
                 backtest,
             });
-            await self.params.onProfit(symbol, data.strategyName, data.exchangeName, data, currentPrice, level, backtest, when.getTime());
+            await self.params.onProfit(symbol, data.strategyName, data.exchangeName, data.frameName, data, currentPrice, level, backtest, when.getTime());
         }
     }
     if (shouldPersist) {
@@ -12240,7 +12435,7 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
                 lossPercent,
                 backtest,
             });
-            await self.params.onLoss(symbol, data.strategyName, data.exchangeName, data, currentPrice, level, backtest, when.getTime());
+            await self.params.onLoss(symbol, data.strategyName, data.exchangeName, data.frameName, data, currentPrice, level, backtest, when.getTime());
         }
     }
     if (shouldPersist) {
@@ -12566,10 +12761,11 @@ const CREATE_KEY_FN$4 = (signalId, backtest) => `${signalId}:${backtest ? "backt
  * @param backtest - True if backtest mode
  * @param timestamp - Event timestamp in milliseconds
  */
-const COMMIT_PROFIT_FN = async (symbol, strategyName, exchangeName, data, currentPrice, level, backtest, timestamp) => await partialProfitSubject.next({
+const COMMIT_PROFIT_FN = async (symbol, strategyName, exchangeName, frameName, data, currentPrice, level, backtest, timestamp) => await partialProfitSubject.next({
     symbol,
     strategyName,
     exchangeName,
+    frameName,
     data,
     currentPrice,
     level,
@@ -12591,10 +12787,11 @@ const COMMIT_PROFIT_FN = async (symbol, strategyName, exchangeName, data, curren
  * @param backtest - True if backtest mode
  * @param timestamp - Event timestamp in milliseconds
  */
-const COMMIT_LOSS_FN = async (symbol, strategyName, exchangeName, data, currentPrice, level, backtest, timestamp) => await partialLossSubject.next({
+const COMMIT_LOSS_FN = async (symbol, strategyName, exchangeName, frameName, data, currentPrice, level, backtest, timestamp) => await partialLossSubject.next({
     symbol,
     strategyName,
     exchangeName,
+    frameName,
     data,
     currentPrice,
     level,
@@ -12746,11 +12943,21 @@ class PartialConnectionService {
 
 /**
  * Creates a unique key for memoizing ReportStorage instances.
- * Key format: "symbol:strategyName:backtest" or "symbol:strategyName:live"
- * @param param0 - Tuple of symbol, strategyName and backtest boolean
+ * Key format: "symbol:strategyName:exchangeName:frameName:backtest" or "symbol:strategyName:exchangeName:live"
+ * @param symbol - Trading pair symbol
+ * @param strategyName - Name of the strategy
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name
+ * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$3 = ([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$3 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
 /** Maximum number of events to store in partial reports */
 const MAX_EVENTS$1 = 250;
 /**
@@ -12922,15 +13129,15 @@ class PartialMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
-         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
+         * 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(CREATE_KEY_FN$3, () => new ReportStorage$1());
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$3(symbol, strategyName, exchangeName, frameName, backtest), () => new ReportStorage$1());
         /**
          * Processes profit events and accumulates them.
          * Should be called from partialProfitSubject subscription.
          *
-         * @param data - Profit event data
+         * @param data - Profit event data with frameName wrapper
          *
          * @example
          * ```typescript
@@ -12942,14 +13149,14 @@ class PartialMarkdownService {
             this.loggerService.log("partialMarkdownService tickProfit", {
                 data,
             });
-            const storage = this.getStorage(data.symbol, data.data.strategyName, data.backtest);
+            const storage = this.getStorage(data.symbol, data.data.strategyName, data.exchangeName, data.frameName, data.backtest);
             storage.addProfitEvent(data.data, data.currentPrice, data.level, data.backtest, data.timestamp);
         };
         /**
          * Processes loss events and accumulates them.
          * Should be called from partialLossSubject subscription.
          *
-         * @param data - Loss event data
+         * @param data - Loss event data with frameName wrapper
          *
          * @example
          * ```typescript
@@ -12961,7 +13168,7 @@ class PartialMarkdownService {
             this.loggerService.log("partialMarkdownService tickLoss", {
                 data,
             });
-            const storage = this.getStorage(data.symbol, data.data.strategyName, data.backtest);
+            const storage = this.getStorage(data.symbol, data.data.strategyName, data.exchangeName, data.frameName, data.backtest);
             storage.addLossEvent(data.data, data.currentPrice, data.level, data.backtest, data.timestamp);
         };
         /**
@@ -12970,23 +13177,27 @@ class PartialMarkdownService {
          *
          * @param symbol - Trading pair symbol to get data for
          * @param strategyName - Strategy name to get data for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new PartialMarkdownService();
-         * const stats = await service.getData("BTCUSDT", "my-strategy", false);
+         * const stats = await service.getData("BTCUSDT", "my-strategy", "binance", "1h", false);
          * console.log(stats.totalProfit, stats.totalLoss);
          * ```
          */
-        this.getData = async (symbol, strategyName, backtest) => {
+        this.getData = async (symbol, strategyName, exchangeName, frameName, backtest) => {
             this.loggerService.log("partialMarkdownService getData", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getData();
         };
         /**
@@ -12995,6 +13206,8 @@ class PartialMarkdownService {
          *
          * @param symbol - Trading pair symbol to generate report for
          * @param strategyName - Strategy name to generate report for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
@@ -13002,17 +13215,19 @@ class PartialMarkdownService {
          * @example
          * ```typescript
          * const service = new PartialMarkdownService();
-         * const markdown = await service.getReport("BTCUSDT", "my-strategy", false);
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy", "binance", "1h", false);
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, backtest, columns = COLUMN_CONFIG.partial_columns) => {
+        this.getReport = async (symbol, strategyName, exchangeName, frameName, backtest, columns = COLUMN_CONFIG.partial_columns) => {
             this.loggerService.log("partialMarkdownService getReport", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getReport(symbol, strategyName, columns);
         };
         /**
@@ -13022,6 +13237,8 @@ class PartialMarkdownService {
          *
          * @param symbol - Trading pair symbol to save report for
          * @param strategyName - Strategy name to save report for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @param path - Directory path to save report (default: "./dump/partial")
          * @param columns - Column configuration for formatting the table
@@ -13031,48 +13248,48 @@ class PartialMarkdownService {
          * const service = new PartialMarkdownService();
          *
          * // Save to default path: ./dump/partial/BTCUSDT_my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", false);
+         * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false);
          *
          * // Save to custom path: ./custom/path/BTCUSDT_my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", false, "./custom/path");
+         * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, backtest, path = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) => {
+        this.dump = async (symbol, strategyName, exchangeName, frameName, backtest, path = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) => {
             this.loggerService.log("partialMarkdownService dump", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
                 path,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             await storage.dump(symbol, strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
-         * If ctx is provided, clears only that specific symbol-strategy-backtest triple's data.
+         * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
          * If nothing is provided, clears all data.
          *
-         * @param backtest - Backtest mode flag
-         * @param ctx - Optional context with symbol and strategyName
+         * @param payload - Optional payload with symbol, strategyName, exchangeName, frameName, backtest
          *
          * @example
          * ```typescript
          * const service = new PartialMarkdownService();
          *
-         * // Clear specific symbol-strategy-backtest triple
-         * await service.clear(false, { symbol: "BTCUSDT", strategyName: "my-strategy" });
+         * // Clear specific combination
+         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy", exchangeName: "binance", frameName: "1h", backtest: false });
          *
          * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (backtest, ctx) => {
+        this.clear = async (payload) => {
             this.loggerService.log("partialMarkdownService clear", {
-                backtest,
-                ctx,
+                payload,
             });
-            if (ctx) {
-                const key = CREATE_KEY_FN$3([ctx.symbol, ctx.strategyName, backtest]);
+            if (payload) {
+                const key = CREATE_KEY_FN$3(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -13153,18 +13370,18 @@ class PartialGlobalService {
         this.riskValidationService = inject(TYPES.riskValidationService);
         /**
          * Validates strategy and associated risk configuration.
-         * Memoized to avoid redundant validations for the same strategy.
+         * Memoized to avoid redundant validations for the same strategy-exchange-frame combination.
          *
-         * @param strategyName - Name of the strategy to validate
+         * @param context - Context with strategyName, exchangeName and frameName
          * @param methodName - Name of the calling method for error tracking
          */
-        this.validate = memoize(([strategyName]) => `${strategyName}`, (strategyName, methodName) => {
+        this.validate = memoize(([context]) => `${context.strategyName}:${context.exchangeName}:${context.frameName}`, (context, methodName) => {
             this.loggerService.log("partialGlobalService validate", {
-                strategyName,
+                context,
                 methodName,
             });
-            this.strategyValidationService.validate(strategyName, methodName);
-            const { riskName, riskList } = this.strategySchemaService.get(strategyName);
+            this.strategyValidationService.validate(context.strategyName, methodName);
+            const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
             riskName && this.riskValidationService.validate(riskName, methodName);
             riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, methodName));
         });
@@ -13190,7 +13407,11 @@ class PartialGlobalService {
                 backtest,
                 when,
             });
-            this.validate(data.strategyName, "partialGlobalService profit");
+            this.validate({
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName
+            }, "partialGlobalService profit");
             return await this.partialConnectionService.profit(symbol, data, currentPrice, revenuePercent, backtest, when);
         };
         /**
@@ -13215,7 +13436,11 @@ class PartialGlobalService {
                 backtest,
                 when,
             });
-            this.validate(data.strategyName, "partialGlobalService loss");
+            this.validate({
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName
+            }, "partialGlobalService loss");
             return await this.partialConnectionService.loss(symbol, data, currentPrice, lossPercent, backtest, when);
         };
         /**
@@ -13235,7 +13460,11 @@ class PartialGlobalService {
                 priceClose,
                 backtest,
             });
-            this.validate(data.strategyName, "partialGlobalService clear");
+            this.validate({
+                strategyName: data.strategyName,
+                exchangeName: data.exchangeName,
+                frameName: data.frameName
+            }, "partialGlobalService clear");
             return await this.partialConnectionService.clear(symbol, data, priceClose, backtest);
         };
     }
@@ -13245,7 +13474,7 @@ class PartialGlobalService {
  * Warning threshold for message size in kilobytes.
  * Messages exceeding this size trigger console warnings.
  */
-const WARN_KB = 20;
+const WARN_KB = 30;
 /**
  * Internal function for dumping signal data to markdown files.
  * Creates a directory structure with system prompts, user messages, and LLM output.
@@ -13509,13 +13738,21 @@ class ConfigValidationService {
 
 /**
  * Creates a unique key for memoizing ReportStorage instances.
- * Key format: "symbol:strategyName:backtest" or "symbol:strategyName:live"
+ * Key format: "symbol:strategyName:exchangeName:frameName:backtest" or "symbol:strategyName:exchangeName:live"
  * @param symbol - Trading pair symbol
  * @param strategyName - Name of the strategy
+ * @param exchangeName - Exchange name
+ * @param frameName - Frame name
  * @param backtest - Whether running in backtest mode
  * @returns Unique string key for memoization
  */
-const CREATE_KEY_FN$2 = (symbol, strategyName, backtest) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$2 = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
 /** Maximum number of events to store in risk reports */
 const MAX_EVENTS = 250;
 /**
@@ -13657,15 +13894,15 @@ class RiskMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a symbol-strategy-backtest triple.
-         * Each symbol-strategy-backtest combination gets its own isolated storage instance.
+         * 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, backtest]) => CREATE_KEY_FN$2(symbol, strategyName, backtest), () => new ReportStorage());
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$2(symbol, strategyName, exchangeName, frameName, backtest), () => new ReportStorage());
         /**
          * Processes risk rejection events and accumulates them.
          * Should be called from riskSubject subscription.
          *
-         * @param data - Risk rejection event data
+         * @param data - Risk rejection event data with frameName wrapper
          *
          * @example
          * ```typescript
@@ -13677,7 +13914,7 @@ class RiskMarkdownService {
             this.loggerService.log("riskMarkdownService tickRejection", {
                 data,
             });
-            const storage = this.getStorage(data.symbol, data.strategyName, data.backtest);
+            const storage = this.getStorage(data.symbol, data.strategyName, data.exchangeName, data.frameName, data.backtest);
             storage.addRejectionEvent(data);
         };
         /**
@@ -13686,23 +13923,27 @@ class RiskMarkdownService {
          *
          * @param symbol - Trading pair symbol to get data for
          * @param strategyName - Strategy name to get data for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new RiskMarkdownService();
-         * const stats = await service.getData("BTCUSDT", "my-strategy", false);
+         * const stats = await service.getData("BTCUSDT", "my-strategy", "binance", "1h", false);
          * console.log(stats.totalRejections, stats.bySymbol);
          * ```
          */
-        this.getData = async (symbol, strategyName, backtest) => {
+        this.getData = async (symbol, strategyName, exchangeName, frameName, backtest) => {
             this.loggerService.log("riskMarkdownService getData", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getData();
         };
         /**
@@ -13711,6 +13952,8 @@ class RiskMarkdownService {
          *
          * @param symbol - Trading pair symbol to generate report for
          * @param strategyName - Strategy name to generate report for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
@@ -13718,17 +13961,19 @@ class RiskMarkdownService {
          * @example
          * ```typescript
          * const service = new RiskMarkdownService();
-         * const markdown = await service.getReport("BTCUSDT", "my-strategy", false);
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy", "binance", "1h", false);
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, backtest, columns = COLUMN_CONFIG.risk_columns) => {
+        this.getReport = async (symbol, strategyName, exchangeName, frameName, backtest, columns = COLUMN_CONFIG.risk_columns) => {
             this.loggerService.log("riskMarkdownService getReport", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             return storage.getReport(symbol, strategyName, columns);
         };
         /**
@@ -13738,6 +13983,8 @@ class RiskMarkdownService {
          *
          * @param symbol - Trading pair symbol to save report for
          * @param strategyName - Strategy name to save report for
+         * @param exchangeName - Exchange name
+         * @param frameName - Frame name
          * @param backtest - True if backtest mode, false if live mode
          * @param path - Directory path to save report (default: "./dump/risk")
          * @param columns - Column configuration for formatting the table
@@ -13747,48 +13994,48 @@ class RiskMarkdownService {
          * const service = new RiskMarkdownService();
          *
          * // Save to default path: ./dump/risk/BTCUSDT_my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", false);
+         * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false);
          *
          * // Save to custom path: ./custom/path/BTCUSDT_my-strategy.md
-         * await service.dump("BTCUSDT", "my-strategy", false, "./custom/path");
+         * await service.dump("BTCUSDT", "my-strategy", "binance", "1h", false, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, backtest, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) => {
+        this.dump = async (symbol, strategyName, exchangeName, frameName, backtest, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) => {
             this.loggerService.log("riskMarkdownService dump", {
                 symbol,
                 strategyName,
+                exchangeName,
+                frameName,
                 backtest,
                 path,
             });
-            const storage = this.getStorage(symbol, strategyName, backtest);
+            const storage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
             await storage.dump(symbol, strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
-         * If ctx is provided, clears only that specific symbol-strategy-backtest triple's data.
+         * If payload is provided, clears only that specific symbol-strategy-exchange-frame-backtest combination's data.
          * If nothing is provided, clears all data.
          *
-         * @param backtest - Backtest mode flag
-         * @param ctx - Optional context with symbol and strategyName
+         * @param payload - Optional payload with symbol, strategyName, exchangeName, frameName, backtest
          *
          * @example
          * ```typescript
          * const service = new RiskMarkdownService();
          *
-         * // Clear specific symbol-strategy-backtest triple
-         * await service.clear(false, { symbol: "BTCUSDT", strategyName: "my-strategy" });
+         * // Clear specific combination
+         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy", exchangeName: "binance", frameName: "1h", backtest: false });
          *
          * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (backtest, ctx) => {
+        this.clear = async (payload) => {
             this.loggerService.log("riskMarkdownService clear", {
-                backtest,
-                ctx,
+                payload,
             });
-            if (ctx) {
-                const key = CREATE_KEY_FN$2(ctx.symbol, ctx.strategyName, backtest);
+            if (payload) {
+                const key = CREATE_KEY_FN$2(payload.symbol, payload.strategyName, payload.exchangeName, payload.frameName, payload.backtest);
                 this.getStorage.clear(key);
             }
             else {
@@ -14298,10 +14545,9 @@ const CANCEL_METHOD_NAME = "strategy.cancel";
  * await stop("BTCUSDT", "my-strategy");
  * ```
  */
-async function stop(symbol, strategyName) {
+async function stop(symbol) {
     backtest$1.loggerService.info(STOP_METHOD_NAME, {
         symbol,
-        strategyName,
     });
     if (!ExecutionContextService.hasContext()) {
         throw new Error("stop requires an execution context");
@@ -14310,7 +14556,12 @@ async function stop(symbol, strategyName) {
         throw new Error("stop requires a method context");
     }
     const { backtest: isBacktest } = backtest$1.executionContextService.context;
-    await backtest$1.strategyCoreService.stop(isBacktest, { symbol, strategyName });
+    const { exchangeName, frameName, strategyName } = backtest$1.methodContextService.context;
+    await backtest$1.strategyCoreService.stop(isBacktest, symbol, {
+        exchangeName,
+        frameName,
+        strategyName,
+    });
 }
 /**
  * Cancels the scheduled signal without stopping the strategy.
@@ -14334,10 +14585,9 @@ async function stop(symbol, strategyName) {
  * await cancel("BTCUSDT", "my-strategy", "manual-cancel-001");
  * ```
  */
-async function cancel(symbol, strategyName, cancelId) {
+async function cancel(symbol, cancelId) {
     backtest$1.loggerService.info(CANCEL_METHOD_NAME, {
         symbol,
-        strategyName,
         cancelId,
     });
     if (!ExecutionContextService.hasContext()) {
@@ -14347,7 +14597,8 @@ async function cancel(symbol, strategyName, cancelId) {
         throw new Error("cancel requires a method context");
     }
     const { backtest: isBacktest } = backtest$1.executionContextService.context;
-    await backtest$1.strategyCoreService.cancel(isBacktest, { symbol, strategyName }, cancelId);
+    const { exchangeName, frameName, strategyName } = backtest$1.methodContextService.context;
+    await backtest$1.strategyCoreService.cancel(isBacktest, symbol, { exchangeName, frameName, strategyName }, cancelId);
 }
 
 /**
@@ -16494,42 +16745,73 @@ class BacktestInstance {
                 context,
             });
             {
-                backtest$1.backtestMarkdownService.clear(true, {
+                backtest$1.backtestMarkdownService.clear({
                     symbol,
                     strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    backtest: true,
                 });
-                backtest$1.liveMarkdownService.clear(true, {
+                backtest$1.liveMarkdownService.clear({
                     symbol,
                     strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    backtest: true,
                 });
-                backtest$1.scheduleMarkdownService.clear(true, {
+                backtest$1.scheduleMarkdownService.clear({
                     symbol,
                     strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    backtest: true,
                 });
-                backtest$1.performanceMarkdownService.clear(true, {
+                backtest$1.performanceMarkdownService.clear({
                     symbol,
                     strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    backtest: true,
                 });
-                backtest$1.partialMarkdownService.clear(true, {
+                backtest$1.partialMarkdownService.clear({
                     symbol,
                     strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    backtest: true,
                 });
-                backtest$1.riskMarkdownService.clear(true, {
+                backtest$1.riskMarkdownService.clear({
                     symbol,
                     strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    backtest: true,
                 });
             }
             {
-                backtest$1.strategyCoreService.clear(true, {
+                backtest$1.strategyCoreService.clear({
                     symbol,
                     strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    backtest: true,
                 });
             }
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
-                riskName && backtest$1.riskGlobalService.clear(true, { riskName });
+                riskName && backtest$1.riskGlobalService.clear({
+                    riskName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                    backtest: true,
+                });
                 riskList &&
-                    riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(true, { riskName }));
+                    riskList.forEach((riskName) => backtest$1.riskGlobalService.clear({
+                        riskName,
+                        exchangeName: context.exchangeName,
+                        frameName: context.frameName,
+                        backtest: true,
+                    }));
             }
             return backtest$1.backtestCommandService.run(symbol, context);
         };
@@ -16569,12 +16851,17 @@ class BacktestInstance {
             }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
-                backtest$1.strategyCoreService.stop(true, {
-                    symbol,
+                backtest$1.strategyCoreService.stop(true, symbol, {
                     strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
                 });
                 backtest$1.strategyCoreService
-                    .getPendingSignal(true, symbol, context.strategyName)
+                    .getPendingSignal(true, symbol, {
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: context.frameName,
+                })
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
                         return;
@@ -16694,16 +16981,16 @@ class BacktestUtils {
          * }
          * ```
          */
-        this.getPendingSignal = async (symbol, strategyName) => {
-            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL);
+        this.getPendingSignal = async (symbol, context) => {
+            backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName &&
                     backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL);
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL));
             }
-            return await backtest$1.strategyCoreService.getPendingSignal(true, symbol, strategyName);
+            return await backtest$1.strategyCoreService.getPendingSignal(true, symbol, context);
         };
         /**
          * Retrieves the currently active scheduled signal for the strategy.
@@ -16721,16 +17008,16 @@ class BacktestUtils {
          * }
          * ```
          */
-        this.getScheduledSignal = async (symbol, strategyName) => {
-            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL);
+        this.getScheduledSignal = async (symbol, context) => {
+            backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName &&
                     backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL);
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL));
             }
-            return await backtest$1.strategyCoreService.getScheduledSignal(true, symbol, strategyName);
+            return await backtest$1.strategyCoreService.getScheduledSignal(true, symbol, context);
         };
         /**
          * Stops the strategy from generating new signals.
@@ -16741,24 +17028,29 @@ class BacktestUtils {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to stop
+         * @param context - Execution context with exchangeName and frameName
          * @returns Promise that resolves when stop flag is set
          *
          * @example
          * ```typescript
          * // Stop strategy after some condition
-         * await Backtest.stop("BTCUSDT", "my-strategy");
+         * await Backtest.stop("BTCUSDT", "my-strategy", {
+         *   exchangeName: "binance",
+         *   frameName: "frame1",
+         *   strategyName: "my-strategy"
+         * });
          * ```
          */
-        this.stop = async (symbol, strategyName) => {
-            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_STOP);
+        this.stop = async (symbol, context) => {
+            backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_STOP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName &&
                     backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_STOP);
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_STOP));
             }
-            await backtest$1.strategyCoreService.stop(true, { symbol, strategyName });
+            await backtest$1.strategyCoreService.stop(true, symbol, context);
         };
         /**
          * Cancels the scheduled signal without stopping the strategy.
@@ -16769,102 +17061,126 @@ 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
          * @returns Promise that resolves when scheduled signal is cancelled
          *
          * @example
          * ```typescript
          * // Cancel scheduled signal with custom ID
-         * await Backtest.cancel("BTCUSDT", "my-strategy", "manual-cancel-001");
+         * await Backtest.cancel("BTCUSDT", "my-strategy", {
+         *   exchangeName: "binance",
+         *   frameName: "frame1",
+         *   strategyName: "my-strategy"
+         * }, "manual-cancel-001");
          * ```
          */
-        this.cancel = async (symbol, strategyName, cancelId) => {
-            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_CANCEL);
+        this.cancel = async (symbol, context, cancelId) => {
+            backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CANCEL);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName &&
                     backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CANCEL);
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CANCEL));
             }
-            await backtest$1.strategyCoreService.cancel(true, { symbol, strategyName }, cancelId);
+            await backtest$1.strategyCoreService.cancel(true, symbol, context, cancelId);
         };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
+         * @param context - Execution context with exchangeName and frameName
          * @returns Promise resolving to statistical data object
          *
          * @example
          * ```typescript
-         * const stats = await Backtest.getData("BTCUSDT", "my-strategy");
+         * const stats = await Backtest.getData("BTCUSDT", "my-strategy", {
+         *   exchangeName: "binance",
+         *   frameName: "frame1",
+         *   strategyName: "my-strategy"
+         * });
          * console.log(stats.sharpeRatio, stats.winRate);
          * ```
          */
-        this.getData = async (symbol, strategyName) => {
-            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_GET_DATA);
+        this.getData = async (symbol, context) => {
+            backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_DATA);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName &&
                     backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_DATA);
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_DATA));
             }
-            return await backtest$1.backtestMarkdownService.getData(symbol, strategyName, true);
+            return await backtest$1.backtestMarkdownService.getData(symbol, context.strategyName, context.exchangeName, context.frameName, true);
         };
         /**
          * Generates markdown report with all closed signals for a symbol-strategy pair.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param context - Execution context with exchangeName and frameName
          * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
          * ```typescript
-         * const markdown = await Backtest.getReport("BTCUSDT", "my-strategy");
+         * const markdown = await Backtest.getReport("BTCUSDT", "my-strategy", {
+         *   exchangeName: "binance",
+         *   frameName: "frame1",
+         *   strategyName: "my-strategy"
+         * });
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, columns) => {
-            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_GET_REPORT);
+        this.getReport = async (symbol, context, columns) => {
+            backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName &&
                     backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_REPORT);
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.backtestMarkdownService.getReport(symbol, strategyName, true, columns);
+            return await backtest$1.backtestMarkdownService.getReport(symbol, context.strategyName, context.exchangeName, context.frameName, true, columns);
         };
         /**
          * Saves strategy report to disk.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
+         * @param context - Execution context with exchangeName and frameName
          * @param path - Optional directory path to save report (default: "./dump/backtest")
          * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
          * // Save to default path: ./dump/backtest/my-strategy.md
-         * await Backtest.dump("BTCUSDT", "my-strategy");
+         * await Backtest.dump("BTCUSDT", "my-strategy", {
+         *   exchangeName: "binance",
+         *   frameName: "frame1",
+         *   strategyName: "my-strategy"
+         * });
          *
          * // Save to custom path: ./custom/path/my-strategy.md
-         * await Backtest.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * await Backtest.dump("BTCUSDT", "my-strategy", {
+         *   exchangeName: "binance",
+         *   frameName: "frame1",
+         *   strategyName: "my-strategy"
+         * }, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path, columns) => {
-            backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_DUMP);
+        this.dump = async (symbol, context, path, columns) => {
+            backtest$1.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName &&
                     backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_DUMP);
                 riskList &&
                     riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_DUMP));
             }
-            await backtest$1.backtestMarkdownService.dump(symbol, strategyName, true, path, columns);
+            await backtest$1.backtestMarkdownService.dump(symbol, context.strategyName, context.exchangeName, context.frameName, true, path, columns);
         };
         /**
          * Lists all active backtest instances with their current status.
@@ -17039,20 +17355,36 @@ class LiveInstance {
                 context,
             });
             {
-                backtest$1.backtestMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
-                backtest$1.liveMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
-                backtest$1.scheduleMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
-                backtest$1.performanceMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
-                backtest$1.partialMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
-                backtest$1.riskMarkdownService.clear(false, { symbol, strategyName: context.strategyName });
+                backtest$1.backtestMarkdownService.clear({ symbol, strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "", backtest: false });
+                backtest$1.liveMarkdownService.clear({ symbol, strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "", backtest: false });
+                backtest$1.scheduleMarkdownService.clear({ symbol, strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "", backtest: false });
+                backtest$1.performanceMarkdownService.clear({ symbol, strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "", backtest: false });
+                backtest$1.partialMarkdownService.clear({ symbol, strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "", backtest: false });
+                backtest$1.riskMarkdownService.clear({ symbol, strategyName: context.strategyName, exchangeName: context.exchangeName, frameName: "", backtest: false });
             }
             {
-                backtest$1.strategyCoreService.clear(false, { symbol, strategyName: context.strategyName });
+                backtest$1.strategyCoreService.clear({
+                    symbol,
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                    backtest: false,
+                });
             }
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
-                riskName && backtest$1.riskGlobalService.clear(false, { riskName });
-                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(false, { riskName }));
+                riskName && backtest$1.riskGlobalService.clear({
+                    riskName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                    backtest: false
+                });
+                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear({
+                    riskName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                    backtest: false
+                }));
             }
             return backtest$1.liveCommandService.run(symbol, context);
         };
@@ -17092,9 +17424,17 @@ class LiveInstance {
             }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
-                backtest$1.strategyCoreService.stop(false, { symbol, strategyName: context.strategyName });
+                backtest$1.strategyCoreService.stop(false, symbol, {
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: ""
+                });
                 backtest$1.strategyCoreService
-                    .getPendingSignal(false, symbol, context.strategyName)
+                    .getPendingSignal(false, symbol, {
+                    strategyName: context.strategyName,
+                    exchangeName: context.exchangeName,
+                    frameName: "",
+                })
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
                         return;
@@ -17221,14 +17561,18 @@ class LiveUtils {
          * }
          * ```
          */
-        this.getPendingSignal = async (symbol, strategyName) => {
-            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
+        this.getPendingSignal = async (symbol, context) => {
+            backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_PENDING_SIGNAL));
             }
-            return await backtest$1.strategyCoreService.getPendingSignal(false, symbol, strategyName);
+            return await backtest$1.strategyCoreService.getPendingSignal(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
         };
         /**
          * Retrieves the currently active scheduled signal for the strategy.
@@ -17246,14 +17590,18 @@ class LiveUtils {
          * }
          * ```
          */
-        this.getScheduledSignal = async (symbol, strategyName) => {
-            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
+        this.getScheduledSignal = async (symbol, context) => {
+            backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL));
             }
-            return await backtest$1.strategyCoreService.getScheduledSignal(false, symbol, strategyName);
+            return await backtest$1.strategyCoreService.getScheduledSignal(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
         };
         /**
          * Stops the strategy from generating new signals.
@@ -17272,14 +17620,18 @@ class LiveUtils {
          * await Live.stop("BTCUSDT", "my-strategy");
          * ```
          */
-        this.stop = async (symbol, strategyName) => {
-            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_STOP);
+        this.stop = async (symbol, context) => {
+            backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_STOP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP));
             }
-            await backtest$1.strategyCoreService.stop(false, { symbol, strategyName });
+            await backtest$1.strategyCoreService.stop(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            });
         };
         /**
          * Cancels the scheduled signal without stopping the strategy.
@@ -17290,94 +17642,122 @@ 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
          * @returns Promise that resolves when scheduled signal is cancelled
          *
          * @example
          * ```typescript
          * // Cancel scheduled signal in live trading with custom ID
-         * await Live.cancel("BTCUSDT", "my-strategy", "manual-cancel-001");
+         * await Live.cancel("BTCUSDT", "my-strategy", {
+         *   exchangeName: "binance",
+         *   frameName: "",
+         *   strategyName: "my-strategy"
+         * }, "manual-cancel-001");
          * ```
          */
-        this.cancel = async (symbol, strategyName, cancelId) => {
-            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_CANCEL);
+        this.cancel = async (symbol, context, cancelId) => {
+            backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CANCEL);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL));
             }
-            await backtest$1.strategyCoreService.cancel(false, { symbol, strategyName }, cancelId);
+            await backtest$1.strategyCoreService.cancel(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }, cancelId);
         };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
+         * @param context - Execution context with exchangeName and frameName
          * @returns Promise resolving to statistical data object
          *
          * @example
          * ```typescript
-         * const stats = await Live.getData("BTCUSDT", "my-strategy");
+         * const stats = await Live.getData("BTCUSDT", "my-strategy", {
+         *   exchangeName: "binance",
+         *   frameName: "",
+         *   strategyName: "my-strategy"
+         * });
          * console.log(stats.sharpeRatio, stats.winRate);
          * ```
          */
-        this.getData = async (symbol, strategyName) => {
-            backtest$1.strategyValidationService.validate(strategyName, "LiveUtils.getData");
+        this.getData = async (symbol, context) => {
+            backtest$1.strategyValidationService.validate(context.strategyName, "LiveUtils.getData");
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_DATA));
             }
-            return await backtest$1.liveMarkdownService.getData(symbol, strategyName, false);
+            return await backtest$1.liveMarkdownService.getData(symbol, context.strategyName, context.exchangeName, "", false);
         };
         /**
          * Generates markdown report with all events for a symbol-strategy pair.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param context - Execution context with exchangeName and frameName
          * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
          * ```typescript
-         * const markdown = await Live.getReport("BTCUSDT", "my-strategy");
+         * const markdown = await Live.getReport("BTCUSDT", "my-strategy", {
+         *   exchangeName: "binance",
+         *   frameName: "",
+         *   strategyName: "my-strategy"
+         * });
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, columns) => {
-            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_GET_REPORT);
+        this.getReport = async (symbol, context, columns) => {
+            backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.liveMarkdownService.getReport(symbol, strategyName, false, columns);
+            return await backtest$1.liveMarkdownService.getReport(symbol, context.strategyName, context.exchangeName, "", false, columns);
         };
         /**
          * Saves strategy report to disk.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
+         * @param context - Execution context with exchangeName and frameName
          * @param path - Optional directory path to save report (default: "./dump/live")
          * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
          * // Save to default path: ./dump/live/my-strategy.md
-         * await Live.dump("BTCUSDT", "my-strategy");
+         * await Live.dump("BTCUSDT", "my-strategy", {
+         *   exchangeName: "binance",
+         *   frameName: "",
+         *   strategyName: "my-strategy"
+         * });
          *
          * // Save to custom path: ./custom/path/my-strategy.md
-         * await Live.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * await Live.dump("BTCUSDT", "my-strategy", {
+         *   exchangeName: "binance",
+         *   frameName: "",
+         *   strategyName: "my-strategy"
+         * }, "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path, columns) => {
-            backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_DUMP);
+        this.dump = async (symbol, context, path, columns) => {
+            backtest$1.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP));
             }
-            await backtest$1.liveMarkdownService.dump(symbol, strategyName, false, path, columns);
+            await backtest$1.liveMarkdownService.dump(symbol, context.strategyName, context.exchangeName, "", false, path, columns);
         };
         /**
          * Lists all active live trading instances with their current status.
@@ -17458,19 +17838,19 @@ class ScheduleUtils {
          * console.log(stats.cancellationRate, stats.avgWaitTime);
          * ```
          */
-        this.getData = async (symbol, strategyName, backtest = false) => {
+        this.getData = async (symbol, context, backtest = false) => {
             backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_GET_DATA, {
                 symbol,
-                strategyName,
+                strategyName: context.strategyName,
                 backtest,
             });
-            backtest$1.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_GET_DATA);
+            backtest$1.strategyValidationService.validate(context.strategyName, SCHEDULE_METHOD_NAME_GET_DATA);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_DATA);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_DATA));
             }
-            return await backtest$1.scheduleMarkdownService.getData(symbol, strategyName, backtest);
+            return await backtest$1.scheduleMarkdownService.getData(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
         };
         /**
          * Generates markdown report with all scheduled events for a symbol-strategy pair.
@@ -17486,19 +17866,19 @@ class ScheduleUtils {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName, backtest = false, columns) => {
+        this.getReport = async (symbol, context, backtest = false, columns) => {
             backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_GET_REPORT, {
                 symbol,
-                strategyName,
+                strategyName: context.strategyName,
                 backtest,
             });
-            backtest$1.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_GET_REPORT);
+            backtest$1.strategyValidationService.validate(context.strategyName, SCHEDULE_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.scheduleMarkdownService.getReport(symbol, strategyName, backtest, columns);
+            return await backtest$1.scheduleMarkdownService.getReport(symbol, context.strategyName, context.exchangeName, context.frameName, backtest, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -17517,20 +17897,20 @@ class ScheduleUtils {
          * await Schedule.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, backtest = false, path, columns) => {
+        this.dump = async (symbol, context, backtest = false, path, columns) => {
             backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_DUMP, {
                 symbol,
-                strategyName,
+                strategyName: context.strategyName,
                 backtest,
                 path,
             });
-            backtest$1.strategyValidationService.validate(strategyName, SCHEDULE_METHOD_NAME_DUMP);
+            backtest$1.strategyValidationService.validate(context.strategyName, SCHEDULE_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP));
             }
-            await backtest$1.scheduleMarkdownService.dump(symbol, strategyName, backtest, path, columns);
+            await backtest$1.scheduleMarkdownService.dump(symbol, context.strategyName, context.exchangeName, context.frameName, backtest, path, columns);
         };
     }
 }
@@ -17611,14 +17991,14 @@ class Performance {
      * }
      * ```
      */
-    static async getData(symbol, strategyName, backtest = false) {
-        backtest$1.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_GET_DATA);
+    static async getData(symbol, context, backtest = false) {
+        backtest$1.strategyValidationService.validate(context.strategyName, PERFORMANCE_METHOD_NAME_GET_DATA);
         {
-            const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+            const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
             riskName && backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_DATA);
             riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_DATA));
         }
-        return backtest$1.performanceMarkdownService.getData(symbol, strategyName, backtest);
+        return backtest$1.performanceMarkdownService.getData(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
     }
     /**
      * Generates markdown report with performance analysis.
@@ -17643,14 +18023,14 @@ class Performance {
      * await fs.writeFile("performance-report.md", markdown);
      * ```
      */
-    static async getReport(symbol, strategyName, backtest = false, columns) {
-        backtest$1.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_GET_REPORT);
+    static async getReport(symbol, context, backtest = false, columns) {
+        backtest$1.strategyValidationService.validate(context.strategyName, PERFORMANCE_METHOD_NAME_GET_REPORT);
         {
-            const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+            const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
             riskName && backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT);
             riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT));
         }
-        return backtest$1.performanceMarkdownService.getReport(symbol, strategyName, backtest, columns);
+        return backtest$1.performanceMarkdownService.getReport(symbol, context.strategyName, context.exchangeName, context.frameName, backtest, columns);
     }
     /**
      * Saves performance report to disk.
@@ -17672,14 +18052,14 @@ class Performance {
      * await Performance.dump("BTCUSDT", "my-strategy", "./reports/perf");
      * ```
      */
-    static async dump(symbol, strategyName, backtest = false, path = "./dump/performance", columns) {
-        backtest$1.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_DUMP);
+    static async dump(symbol, context, backtest = false, path = "./dump/performance", columns) {
+        backtest$1.strategyValidationService.validate(context.strategyName, PERFORMANCE_METHOD_NAME_DUMP);
         {
-            const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+            const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
             riskName && backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP);
             riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP));
         }
-        return backtest$1.performanceMarkdownService.dump(symbol, strategyName, backtest, path, columns);
+        return backtest$1.performanceMarkdownService.dump(symbol, context.strategyName, context.exchangeName, context.frameName, backtest, path, columns);
     }
 }
 
@@ -17817,21 +18197,37 @@ class WalkerInstance {
             // Clear backtest data for all strategies
             for (const strategyName of walkerSchema.strategies) {
                 {
-                    backtest$1.backtestMarkdownService.clear(true, { symbol, strategyName });
-                    backtest$1.liveMarkdownService.clear(true, { symbol, strategyName });
-                    backtest$1.scheduleMarkdownService.clear(true, { symbol, strategyName });
-                    backtest$1.performanceMarkdownService.clear(true, { symbol, strategyName });
-                    backtest$1.partialMarkdownService.clear(true, { symbol, strategyName });
-                    backtest$1.riskMarkdownService.clear(true, { symbol, strategyName });
+                    backtest$1.backtestMarkdownService.clear({ symbol, strategyName, exchangeName: walkerSchema.exchangeName, frameName: walkerSchema.frameName, backtest: true });
+                    backtest$1.liveMarkdownService.clear({ symbol, strategyName, exchangeName: walkerSchema.exchangeName, frameName: walkerSchema.frameName, backtest: true });
+                    backtest$1.scheduleMarkdownService.clear({ symbol, strategyName, exchangeName: walkerSchema.exchangeName, frameName: walkerSchema.frameName, backtest: true });
+                    backtest$1.performanceMarkdownService.clear({ symbol, strategyName, exchangeName: walkerSchema.exchangeName, frameName: walkerSchema.frameName, backtest: true });
+                    backtest$1.partialMarkdownService.clear({ symbol, strategyName, exchangeName: walkerSchema.exchangeName, frameName: walkerSchema.frameName, backtest: true });
+                    backtest$1.riskMarkdownService.clear({ symbol, strategyName, exchangeName: walkerSchema.exchangeName, frameName: walkerSchema.frameName, backtest: true });
                 }
                 {
-                    backtest$1.strategyCoreService.clear(true, { symbol, strategyName });
+                    backtest$1.strategyCoreService.clear({
+                        symbol,
+                        strategyName,
+                        exchangeName: walkerSchema.exchangeName,
+                        frameName: walkerSchema.frameName,
+                        backtest: true,
+                    });
                 }
                 {
                     const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                    riskName && backtest$1.riskGlobalService.clear(true, { riskName });
+                    riskName && backtest$1.riskGlobalService.clear({
+                        riskName,
+                        exchangeName: walkerSchema.exchangeName,
+                        frameName: walkerSchema.frameName,
+                        backtest: true
+                    });
                     riskList &&
-                        riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(true, { riskName }));
+                        riskList.forEach((riskName) => backtest$1.riskGlobalService.clear({
+                            riskName,
+                            exchangeName: walkerSchema.exchangeName,
+                            frameName: walkerSchema.frameName,
+                            backtest: true
+                        }));
                 }
             }
             return backtest$1.walkerCommandService.run(symbol, {
@@ -17876,7 +18272,11 @@ class WalkerInstance {
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
-                    backtest$1.strategyCoreService.stop(true, { symbol, strategyName });
+                    backtest$1.strategyCoreService.stop(true, symbol, {
+                        strategyName,
+                        exchangeName: walkerSchema.exchangeName,
+                        frameName: walkerSchema.frameName
+                    });
                     walkerStopSubject.next({
                         symbol,
                         strategyName,
@@ -18017,7 +18417,11 @@ class WalkerUtils {
             }
             for (const strategyName of walkerSchema.strategies) {
                 await walkerStopSubject.next({ symbol, strategyName, walkerName });
-                await backtest$1.strategyCoreService.stop(true, { symbol, strategyName });
+                await backtest$1.strategyCoreService.stop(true, symbol, {
+                    strategyName,
+                    exchangeName: walkerSchema.exchangeName,
+                    frameName: walkerSchema.frameName
+                });
             }
         };
         /**
@@ -18165,15 +18569,27 @@ const HEAT_METHOD_NAME_DUMP = "HeatUtils.dump";
  * import { Heat } from "backtest-kit";
  *
  * // Get raw heatmap data for a strategy
- * const stats = await Heat.getData("my-strategy");
+ * const stats = await Heat.getData({
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "frame1"
+ * });
  * console.log(`Portfolio PNL: ${stats.portfolioTotalPnl}%`);
  *
  * // Generate markdown report
- * const markdown = await Heat.getReport("my-strategy");
+ * const markdown = await Heat.getReport({
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "frame1"
+ * });
  * console.log(markdown);
  *
  * // Save to disk
- * await Heat.dump("my-strategy", "./reports");
+ * await Heat.dump({
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "frame1"
+ * }, false, "./reports");
  * ```
  */
 class HeatUtils {
@@ -18184,12 +18600,17 @@ class HeatUtils {
          * Returns per-symbol breakdown and portfolio-wide metrics.
          * Data is automatically collected from all closed signals for the strategy.
          *
-         * @param strategyName - Strategy name to get heatmap data for
+         * @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 heatmap statistics object
          *
          * @example
          * ```typescript
-         * const stats = await Heat.getData("my-strategy");
+         * const stats = await Heat.getData({
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance",
+         *   frameName: "frame1"
+         * });
          *
          * console.log(`Total symbols: ${stats.totalSymbols}`);
          * console.log(`Portfolio Total PNL: ${stats.portfolioTotalPnl}%`);
@@ -18201,15 +18622,15 @@ class HeatUtils {
          * });
          * ```
          */
-        this.getData = async (strategyName, backtest = false) => {
-            backtest$1.loggerService.info(HEAT_METHOD_NAME_GET_DATA, { strategyName });
-            backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_GET_DATA);
+        this.getData = async (context, backtest = false) => {
+            backtest$1.loggerService.info(HEAT_METHOD_NAME_GET_DATA, { strategyName: context.strategyName });
+            backtest$1.strategyValidationService.validate(context.strategyName, HEAT_METHOD_NAME_GET_DATA);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_DATA);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_DATA));
             }
-            return await backtest$1.heatMarkdownService.getData(strategyName, backtest);
+            return await backtest$1.heatMarkdownService.getData(context.exchangeName, context.frameName, backtest);
         };
         /**
          * Generates markdown report with portfolio heatmap table for a strategy.
@@ -18217,13 +18638,18 @@ class HeatUtils {
          * Table includes: Symbol, Total PNL, Sharpe Ratio, Max Drawdown, Trades.
          * Symbols are sorted by Total PNL descending.
          *
-         * @param strategyName - Strategy name to generate heatmap report for
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
          * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
          * ```typescript
-         * const markdown = await Heat.getReport("my-strategy");
+         * const markdown = await Heat.getReport({
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance",
+         *   frameName: "frame1"
+         * });
          * console.log(markdown);
          * // Output:
          * // # Portfolio Heatmap: my-strategy
@@ -18237,15 +18663,15 @@ class HeatUtils {
          * // ...
          * ```
          */
-        this.getReport = async (strategyName, backtest = false, columns) => {
-            backtest$1.loggerService.info(HEAT_METHOD_NAME_GET_REPORT, { strategyName });
-            backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_GET_REPORT);
+        this.getReport = async (context, backtest = false, columns) => {
+            backtest$1.loggerService.info(HEAT_METHOD_NAME_GET_REPORT, { strategyName: context.strategyName });
+            backtest$1.strategyValidationService.validate(context.strategyName, HEAT_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.heatMarkdownService.getReport(strategyName, backtest, columns);
+            return await backtest$1.heatMarkdownService.getReport(context.strategyName, context.exchangeName, context.frameName, backtest, columns);
         };
         /**
          * Saves heatmap report to disk for a strategy.
@@ -18253,28 +18679,37 @@ class HeatUtils {
          * Creates directory if it doesn't exist.
          * Default filename: {strategyName}.md
          *
-         * @param strategyName - Strategy name to save heatmap report for
+         * @param context - Execution context with strategyName, exchangeName and frameName
+         * @param backtest - True if backtest mode, false if live mode (default: false)
          * @param path - Optional directory path to save report (default: "./dump/heatmap")
          * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
          * // Save to default path: ./dump/heatmap/my-strategy.md
-         * await Heat.dump("my-strategy");
+         * await Heat.dump({
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance",
+         *   frameName: "frame1"
+         * });
          *
          * // Save to custom path: ./reports/my-strategy.md
-         * await Heat.dump("my-strategy", "./reports");
+         * await Heat.dump({
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance",
+         *   frameName: "frame1"
+         * }, false, "./reports");
          * ```
          */
-        this.dump = async (strategyName, backtest = false, path, columns) => {
-            backtest$1.loggerService.info(HEAT_METHOD_NAME_DUMP, { strategyName, path });
-            backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_DUMP);
+        this.dump = async (context, backtest = false, path, columns) => {
+            backtest$1.loggerService.info(HEAT_METHOD_NAME_DUMP, { strategyName: context.strategyName, path });
+            backtest$1.strategyValidationService.validate(context.strategyName, HEAT_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP));
             }
-            await backtest$1.heatMarkdownService.dump(strategyName, backtest, path, columns);
+            await backtest$1.heatMarkdownService.dump(context.strategyName, context.exchangeName, context.frameName, backtest, path, columns);
         };
     }
 }
@@ -18286,7 +18721,11 @@ class HeatUtils {
  * import { Heat } from "backtest-kit";
  *
  * // Strategy-specific heatmap
- * const stats = await Heat.getData("my-strategy");
+ * const stats = await Heat.getData({
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "frame1"
+ * });
  * console.log(`Portfolio PNL: ${stats.portfolioTotalPnl}%`);
  * console.log(`Total Symbols: ${stats.totalSymbols}`);
  *
@@ -18300,7 +18739,11 @@ class HeatUtils {
  * });
  *
  * // Generate and save report
- * await Heat.dump("my-strategy", "./reports");
+ * await Heat.dump({
+ *   strategyName: "my-strategy",
+ *   exchangeName: "binance",
+ *   frameName: "frame1"
+ * }, false, "./reports");
  * ```
  */
 const Heat = new HeatUtils();
@@ -18590,15 +19033,15 @@ class PartialUtils {
          * }
          * ```
          */
-        this.getData = async (symbol, strategyName, backtest = false) => {
-            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_DATA, { symbol, strategyName });
-            backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_GET_DATA);
+        this.getData = async (symbol, context, backtest = false) => {
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_DATA, { symbol, strategyName: context.strategyName });
+            backtest$1.strategyValidationService.validate(context.strategyName, PARTIAL_METHOD_NAME_GET_DATA);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_DATA);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_DATA));
             }
-            return await backtest$1.partialMarkdownService.getData(symbol, strategyName, backtest);
+            return await backtest$1.partialMarkdownService.getData(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
         };
         /**
          * Generates markdown report with all partial profit/loss events for a symbol-strategy pair.
@@ -18639,15 +19082,15 @@ class PartialUtils {
          * // **Loss events:** 1
          * ```
          */
-        this.getReport = async (symbol, strategyName, backtest = false, columns) => {
-            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol, strategyName });
-            backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_GET_REPORT);
+        this.getReport = async (symbol, context, backtest = false, columns) => {
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol, strategyName: context.strategyName });
+            backtest$1.strategyValidationService.validate(context.strategyName, PARTIAL_METHOD_NAME_GET_REPORT);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.partialMarkdownService.getReport(symbol, strategyName, backtest, columns);
+            return await backtest$1.partialMarkdownService.getReport(symbol, context.strategyName, context.exchangeName, context.frameName, backtest, columns);
         };
         /**
          * Generates and saves markdown report to file.
@@ -18681,15 +19124,15 @@ class PartialUtils {
          * }
          * ```
          */
-        this.dump = async (symbol, strategyName, backtest = false, path, columns) => {
-            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, strategyName, path });
-            backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_DUMP);
+        this.dump = async (symbol, context, backtest = false, path, columns) => {
+            backtest$1.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, strategyName: context.strategyName, path });
+            backtest$1.strategyValidationService.validate(context.strategyName, PARTIAL_METHOD_NAME_DUMP);
             {
-                const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
+                const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
                 riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP));
             }
-            await backtest$1.partialMarkdownService.dump(symbol, strategyName, backtest, path, columns);
+            await backtest$1.partialMarkdownService.dump(symbol, context.strategyName, context.exchangeName, context.frameName, backtest, path, columns);
         };
     }
 }
@@ -19102,7 +19545,13 @@ const INTERVAL_MINUTES = {
  * @param backtest - Whether running in backtest mode
  * @returns Cache key string
  */
-const CREATE_KEY_FN$1 = (strategyName, exchangeName, backtest) => `${strategyName}:${exchangeName}:${backtest ? "backtest" : "live"}`;
+const CREATE_KEY_FN$1 = (strategyName, exchangeName, frameName, backtest) => {
+    const parts = [strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
 /**
  * Instance class for caching function results with timeframe-based invalidation.
  *
@@ -19178,7 +19627,7 @@ class CacheInstance {
                     throw new Error(`CacheInstance unknown cache ttl interval=${this.interval}`);
                 }
             }
-            const key = CREATE_KEY_FN$1(backtest$1.methodContextService.context.strategyName, backtest$1.methodContextService.context.exchangeName, backtest$1.executionContextService.context.backtest);
+            const key = CREATE_KEY_FN$1(backtest$1.methodContextService.context.strategyName, backtest$1.methodContextService.context.exchangeName, backtest$1.methodContextService.context.frameName, backtest$1.executionContextService.context.backtest);
             const currentWhen = backtest$1.executionContextService.context.when;
             const cached = this._cacheMap.get(key);
             if (cached) {
@@ -19216,7 +19665,7 @@ class CacheInstance {
          * ```
          */
         this.clear = () => {
-            const key = CREATE_KEY_FN$1(backtest$1.methodContextService.context.strategyName, backtest$1.methodContextService.context.exchangeName, backtest$1.executionContextService.context.backtest);
+            const key = CREATE_KEY_FN$1(backtest$1.methodContextService.context.strategyName, backtest$1.methodContextService.context.exchangeName, backtest$1.methodContextService.context.frameName, backtest$1.executionContextService.context.backtest);
             this._cacheMap.delete(key);
         };
     }