backtest-kit 1.4.6 → 1.4.8

package/build/index.mjs

@@ -1214,24 +1214,25 @@ const PersistBase = makeExtendable(class {
 class PersistSignalUtils {
     constructor() {
         this.PersistSignalFactory = PersistBase;
-        this.getSignalStorage = memoize(([strategyName]) => `${strategyName}`, (strategyName) => Reflect.construct(this.PersistSignalFactory, [
-            strategyName,
+        this.getSignalStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => Reflect.construct(this.PersistSignalFactory, [
+            `${symbol}_${strategyName}`,
             `./dump/data/signal/`,
         ]));
         /**
-         * Reads persisted signal data for a strategy and symbol.
+         * Reads persisted signal data for a symbol and strategy.
          *
          * Called by ClientStrategy.waitForInit() to restore state.
          * Returns null if no signal exists.
          *
-         * @param strategyName - Strategy identifier
          * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
          * @returns Promise resolving to signal or null
          */
-        this.readSignalData = async (strategyName, symbol) => {
+        this.readSignalData = async (symbol, strategyName) => {
             backtest$1.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
-            const isInitial = !this.getSignalStorage.has(strategyName);
-            const stateStorage = this.getSignalStorage(strategyName);
+            const key = `${symbol}:${strategyName}`;
+            const isInitial = !this.getSignalStorage.has(key);
+            const stateStorage = this.getSignalStorage(symbol, strategyName);
             await stateStorage.waitForInit(isInitial);
             if (await stateStorage.hasValue(symbol)) {
                 return await stateStorage.readValue(symbol);
@@ -1245,14 +1246,15 @@ class PersistSignalUtils {
          * Uses atomic writes to prevent corruption on crashes.
          *
          * @param signalRow - Signal data (null to clear)
-         * @param strategyName - Strategy identifier
          * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
          * @returns Promise that resolves when write is complete
          */
-        this.writeSignalData = async (signalRow, strategyName, symbol) => {
+        this.writeSignalData = async (signalRow, symbol, strategyName) => {
             backtest$1.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
-            const isInitial = !this.getSignalStorage.has(strategyName);
-            const stateStorage = this.getSignalStorage(strategyName);
+            const key = `${symbol}:${strategyName}`;
+            const isInitial = !this.getSignalStorage.has(key);
+            const stateStorage = this.getSignalStorage(symbol, strategyName);
             await stateStorage.waitForInit(isInitial);
             await stateStorage.writeValue(symbol, signalRow);
         };
@@ -1403,24 +1405,25 @@ const PersistRiskAdapter = new PersistRiskUtils();
 class PersistScheduleUtils {
     constructor() {
         this.PersistScheduleFactory = PersistBase;
-        this.getScheduleStorage = memoize(([strategyName]) => `${strategyName}`, (strategyName) => Reflect.construct(this.PersistScheduleFactory, [
-            strategyName,
+        this.getScheduleStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => Reflect.construct(this.PersistScheduleFactory, [
+            `${symbol}_${strategyName}`,
             `./dump/data/schedule/`,
         ]));
         /**
-         * Reads persisted scheduled signal data for a strategy and symbol.
+         * Reads persisted scheduled signal data for a symbol and strategy.
          *
          * Called by ClientStrategy.waitForInit() to restore scheduled signal state.
          * Returns null if no scheduled signal exists.
          *
-         * @param strategyName - Strategy identifier
          * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
          * @returns Promise resolving to scheduled signal or null
          */
-        this.readScheduleData = async (strategyName, symbol) => {
+        this.readScheduleData = async (symbol, strategyName) => {
             backtest$1.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
-            const isInitial = !this.getScheduleStorage.has(strategyName);
-            const stateStorage = this.getScheduleStorage(strategyName);
+            const key = `${symbol}:${strategyName}`;
+            const isInitial = !this.getScheduleStorage.has(key);
+            const stateStorage = this.getScheduleStorage(symbol, strategyName);
             await stateStorage.waitForInit(isInitial);
             if (await stateStorage.hasValue(symbol)) {
                 return await stateStorage.readValue(symbol);
@@ -1434,14 +1437,15 @@ class PersistScheduleUtils {
          * Uses atomic writes to prevent corruption on crashes.
          *
          * @param scheduledSignalRow - Scheduled signal data (null to clear)
-         * @param strategyName - Strategy identifier
          * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
          * @returns Promise that resolves when write is complete
          */
-        this.writeScheduleData = async (scheduledSignalRow, strategyName, symbol) => {
+        this.writeScheduleData = async (scheduledSignalRow, symbol, strategyName) => {
             backtest$1.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
-            const isInitial = !this.getScheduleStorage.has(strategyName);
-            const stateStorage = this.getScheduleStorage(strategyName);
+            const key = `${symbol}:${strategyName}`;
+            const isInitial = !this.getScheduleStorage.has(key);
+            const stateStorage = this.getScheduleStorage(symbol, strategyName);
             await stateStorage.waitForInit(isInitial);
             await stateStorage.writeValue(symbol, scheduledSignalRow);
         };
@@ -1825,6 +1829,9 @@ const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
     if (signal.minuteEstimatedTime <= 0) {
         errors.push(`minuteEstimatedTime must be positive, got ${signal.minuteEstimatedTime}`);
     }
+    if (!Number.isInteger(signal.minuteEstimatedTime)) {
+        errors.push(`minuteEstimatedTime must be an integer (whole number), got ${signal.minuteEstimatedTime}`);
+    }
     // ЗАЩИТА ОТ ВЕЧНЫХ СИГНАЛОВ: ограничиваем максимальное время жизни сигнала
     if (GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES && GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES) {
         if (signal.minuteEstimatedTime > GLOBAL_CONFIG.CC_MAX_SIGNAL_LIFETIME_MINUTES) {
@@ -1967,7 +1974,7 @@ const WAIT_FOR_INIT_FN$2 = async (self) => {
         return;
     }
     // Restore pending signal
-    const pendingSignal = await PersistSignalAdapter.readSignalData(self.params.strategyName, self.params.execution.context.symbol);
+    const pendingSignal = await PersistSignalAdapter.readSignalData(self.params.execution.context.symbol, self.params.strategyName);
     if (pendingSignal) {
         if (pendingSignal.exchangeName !== self.params.method.context.exchangeName) {
             return;
@@ -1983,7 +1990,7 @@ const WAIT_FOR_INIT_FN$2 = async (self) => {
         }
     }
     // Restore scheduled signal
-    const scheduledSignal = await PersistScheduleAdapter.readScheduleData(self.params.strategyName, self.params.execution.context.symbol);
+    const scheduledSignal = await PersistScheduleAdapter.readScheduleData(self.params.execution.context.symbol, self.params.strategyName);
     if (scheduledSignal) {
         if (scheduledSignal.exchangeName !== self.params.method.context.exchangeName) {
             return;
@@ -2677,7 +2684,7 @@ class ClientStrategy {
         if (this.params.execution.context.backtest) {
             return;
         }
-        await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.strategyName, this.params.execution.context.symbol);
+        await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName);
     }
     /**
      * Updates scheduled signal and persists to disk in live mode.
@@ -2696,14 +2703,18 @@ class ClientStrategy {
         if (this.params.execution.context.backtest) {
             return;
         }
-        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, this.params.strategyName, this.params.execution.context.symbol);
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, this.params.execution.context.symbol, this.params.strategyName);
     }
     /**
      * Retrieves the current pending signal.
      * If no signal is pending, returns null.
      * @returns Promise resolving to the pending signal or null.
      */
-    async getPendingSignal() {
+    async getPendingSignal(symbol, strategyName) {
+        this.params.logger.debug("ClientStrategy getPendingSignal", {
+            symbol,
+            strategyName,
+        });
         return this._pendingSignal;
     }
     /**
@@ -2736,8 +2747,11 @@ class ClientStrategy {
      * }
      * ```
      */
-    async tick() {
-        this.params.logger.debug("ClientStrategy tick");
+    async tick(symbol, strategyName) {
+        this.params.logger.debug("ClientStrategy tick", {
+            symbol,
+            strategyName,
+        });
         // Получаем текущее время в начале tick для консистентности
         const currentTime = this.params.execution.context.when.getTime();
         // Early return if strategy was stopped
@@ -2822,9 +2836,11 @@ class ClientStrategy {
      * console.log(result.closeReason); // "take_profit" | "stop_loss" | "time_expired" | "cancelled"
      * ```
      */
-    async backtest(candles) {
+    async backtest(symbol, strategyName, candles) {
         this.params.logger.debug("ClientStrategy backtest", {
-            symbol: this.params.execution.context.symbol,
+            symbol,
+            strategyName,
+            contextSymbol: this.params.execution.context.symbol,
             candlesCount: candles.length,
             hasScheduled: !!this._scheduledSignal,
             hasPending: !!this._pendingSignal,
@@ -2940,8 +2956,10 @@ class ClientStrategy {
      * // Existing signal will continue until natural close
      * ```
      */
-    async stop() {
+    async stop(symbol, strategyName) {
         this.params.logger.debug("ClientStrategy stop", {
+            symbol,
+            strategyName,
             hasPendingSignal: this._pendingSignal !== null,
             hasScheduledSignal: this._scheduledSignal !== null,
         });
@@ -2962,21 +2980,20 @@ const NOOP_RISK = {
  * Connection service routing strategy operations to correct ClientStrategy instance.
  *
  * Routes all IStrategy method calls to the appropriate strategy implementation
- * based on methodContextService.context.strategyName. Uses memoization to cache
+ * based on symbol-strategy pairs. Uses memoization to cache
  * ClientStrategy instances for performance.
  *
  * Key features:
- * - Automatic strategy routing via method context
- * - Memoized ClientStrategy instances by strategyName
- * - Implements IStrategy interface
+ * - Automatic strategy routing via symbol-strategy pairs
+ * - Memoized ClientStrategy instances by symbol:strategyName
  * - Ensures initialization with waitForInit() before operations
  * - Handles both tick() (live) and backtest() operations
  *
  * @example
  * ```typescript
  * // Used internally by framework
- * const result = await strategyConnectionService.tick();
- * // Automatically routes to correct strategy based on methodContext
+ * const result = await strategyConnectionService.tick(symbol, strategyName);
+ * // Routes to correct strategy instance for symbol-strategy pair
  * ```
  */
 class StrategyConnectionService {
@@ -2989,17 +3006,19 @@ class StrategyConnectionService {
         this.methodContextService = inject(TYPES.methodContextService);
         this.partialConnectionService = inject(TYPES.partialConnectionService);
         /**
-         * Retrieves memoized ClientStrategy instance for given strategy name.
+         * Retrieves memoized ClientStrategy instance for given symbol-strategy pair.
          *
          * Creates ClientStrategy on first call, returns cached instance on subsequent calls.
-         * Cache key is strategyName string.
+         * Cache key is symbol:strategyName string.
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Name of registered strategy schema
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = memoize(([strategyName]) => `${strategyName}`, (strategyName) => {
+        this.getStrategy = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => {
             const { riskName, getSignal, interval, callbacks } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
+                symbol,
                 interval,
                 execution: this.executionContextService,
                 method: this.methodContextService,
@@ -3018,14 +3037,18 @@ class StrategyConnectionService {
          * If no active signal exists, returns null.
          * Used internally for monitoring TP/SL and time expiration.
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Name of strategy to get pending signal for
          *
          * @returns Promise resolving to pending signal or null
          */
-        this.getPendingSignal = async (strategyName) => {
-            this.loggerService.log("strategyConnectionService getPendingSignal");
-            const strategy = await this.getStrategy(strategyName);
-            return await strategy.getPendingSignal();
+        this.getPendingSignal = async (symbol, strategyName) => {
+            this.loggerService.log("strategyConnectionService getPendingSignal", {
+                symbol,
+                strategyName,
+            });
+            const strategy = this.getStrategy(symbol, strategyName);
+            return await strategy.getPendingSignal(symbol, strategyName);
         };
         /**
          * Executes live trading tick for current strategy.
@@ -3033,13 +3056,18 @@ class StrategyConnectionService {
          * Waits for strategy initialization before processing tick.
          * Evaluates current market conditions and returns signal state.
          *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of strategy to tick
          * @returns Promise resolving to tick result (idle, opened, active, closed)
          */
-        this.tick = async () => {
-            this.loggerService.log("strategyConnectionService tick");
-            const strategy = await this.getStrategy(this.methodContextService.context.strategyName);
+        this.tick = async (symbol, strategyName) => {
+            this.loggerService.log("strategyConnectionService tick", {
+                symbol,
+                strategyName,
+            });
+            const strategy = this.getStrategy(symbol, strategyName);
             await strategy.waitForInit();
-            const tick = await strategy.tick();
+            const tick = await strategy.tick(symbol, strategyName);
             {
                 if (this.executionContextService.context.backtest) {
                     await signalBacktestEmitter.next(tick);
@@ -3057,16 +3085,20 @@ class StrategyConnectionService {
          * Waits for strategy initialization before processing candles.
          * Evaluates strategy signals against historical data.
          *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Name of strategy to backtest
          * @param candles - Array of historical candle data to backtest
          * @returns Promise resolving to backtest result (signal or idle)
          */
-        this.backtest = async (candles) => {
+        this.backtest = async (symbol, strategyName, candles) => {
             this.loggerService.log("strategyConnectionService backtest", {
+                symbol,
+                strategyName,
                 candleCount: candles.length,
             });
-            const strategy = await this.getStrategy(this.methodContextService.context.strategyName);
+            const strategy = this.getStrategy(symbol, strategyName);
             await strategy.waitForInit();
-            const tick = await strategy.backtest(candles);
+            const tick = await strategy.backtest(symbol, strategyName, candles);
             {
                 if (this.executionContextService.context.backtest) {
                     await signalBacktestEmitter.next(tick);
@@ -3081,15 +3113,17 @@ class StrategyConnectionService {
          * Delegates to ClientStrategy.stop() which sets internal flag to prevent
          * getSignal from being called on subsequent ticks.
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Name of strategy to stop
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (strategyName) => {
+        this.stop = async (symbol, strategyName) => {
             this.loggerService.log("strategyConnectionService stop", {
+                symbol,
                 strategyName,
             });
-            const strategy = this.getStrategy(strategyName);
-            await strategy.stop();
+            const strategy = this.getStrategy(symbol, strategyName);
+            await strategy.stop(symbol, strategyName);
         };
         /**
          * Clears the memoized ClientStrategy instance from cache.
@@ -3097,13 +3131,19 @@ class StrategyConnectionService {
          * Forces re-initialization of strategy on next getStrategy call.
          * Useful for resetting strategy state or releasing resources.
          *
-         * @param strategyName - Name of strategy to clear from cache
+         * @param ctx - Optional context with symbol and strategyName (clears all if not provided)
          */
-        this.clear = async (strategyName) => {
+        this.clear = async (ctx) => {
             this.loggerService.log("strategyConnectionService clear", {
-                strategyName,
+                ctx,
             });
-            this.getStrategy.clear(strategyName);
+            if (ctx) {
+                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                this.getStrategy.clear(key);
+            }
+            else {
+                this.getStrategy.clear();
+            }
         };
     }
 }
@@ -3914,13 +3954,15 @@ class StrategyGlobalService {
         /**
          * Validates strategy and associated risk configuration.
          *
-         * Memoized to avoid redundant validations for the same strategy.
+         * Memoized to avoid redundant validations for the same symbol-strategy pair.
          * Logs validation activity.
+         * @param symbol - Trading pair symbol
          * @param strategyName - Name of the strategy to validate
          * @returns Promise that resolves when validation is complete
          */
-        this.validate = memoize(([strategyName]) => `${strategyName}`, async (strategyName) => {
+        this.validate = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, async (symbol, strategyName) => {
             this.loggerService.log(METHOD_NAME_VALIDATE, {
+                symbol,
                 strategyName,
             });
             const strategySchema = this.strategySchemaService.get(strategyName);
@@ -3935,16 +3977,16 @@ class StrategyGlobalService {
          * Used internally for monitoring TP/SL and time expiration.
          *
          * @param symbol - Trading pair symbol
-         * @param when - Timestamp for tick evaluation
-         * @param backtest - Whether running in backtest mode
+         * @param strategyName - Name of the strategy
          * @returns Promise resolving to pending signal or null
          */
-        this.getPendingSignal = async (strategyName) => {
+        this.getPendingSignal = async (symbol, strategyName) => {
             this.loggerService.log("strategyGlobalService getPendingSignal", {
+                symbol,
                 strategyName,
             });
-            await this.validate(this.methodContextService.context.strategyName);
-            return await this.strategyConnectionService.getPendingSignal(strategyName);
+            await this.validate(symbol, strategyName);
+            return await this.strategyConnectionService.getPendingSignal(symbol, strategyName);
         };
         /**
          * Checks signal status at a specific timestamp.
@@ -3963,9 +4005,10 @@ class StrategyGlobalService {
                 when,
                 backtest,
             });
-            await this.validate(this.methodContextService.context.strategyName);
+            const strategyName = this.methodContextService.context.strategyName;
+            await this.validate(symbol, strategyName);
             return await ExecutionContextService.runInContext(async () => {
-                return await this.strategyConnectionService.tick();
+                return await this.strategyConnectionService.tick(symbol, strategyName);
             }, {
                 symbol,
                 when,
@@ -3991,9 +4034,10 @@ class StrategyGlobalService {
                 when,
                 backtest,
             });
-            await this.validate(this.methodContextService.context.strategyName);
+            const strategyName = this.methodContextService.context.strategyName;
+            await this.validate(symbol, strategyName);
             return await ExecutionContextService.runInContext(async () => {
-                return await this.strategyConnectionService.backtest(candles);
+                return await this.strategyConnectionService.backtest(symbol, strategyName, candles);
             }, {
                 symbol,
                 when,
@@ -4006,15 +4050,17 @@ class StrategyGlobalService {
          * Delegates to StrategyConnectionService.stop() to set internal flag.
          * Does not require execution context.
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Name of strategy to stop
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (strategyName) => {
+        this.stop = async (symbol, strategyName) => {
             this.loggerService.log("strategyGlobalService stop", {
+                symbol,
                 strategyName,
             });
-            await this.validate(strategyName);
-            return await this.strategyConnectionService.stop(strategyName);
+            await this.validate(symbol, strategyName);
+            return await this.strategyConnectionService.stop(symbol, strategyName);
         };
         /**
          * Clears the memoized ClientStrategy instance from cache.
@@ -4022,16 +4068,16 @@ class StrategyGlobalService {
          * Delegates to StrategyConnectionService.clear() to remove strategy from cache.
          * Forces re-initialization of strategy on next operation.
          *
-         * @param strategyName - Name of strategy to clear from cache
+         * @param ctx - Optional context with symbol and strategyName (clears all if not provided)
          */
-        this.clear = async (strategyName) => {
+        this.clear = async (ctx) => {
             this.loggerService.log("strategyGlobalService clear", {
-                strategyName,
+                ctx,
             });
-            if (strategyName) {
-                await this.validate(strategyName);
+            if (ctx) {
+                await this.validate(ctx.symbol, ctx.strategyName);
             }
-            return await this.strategyConnectionService.clear(strategyName);
+            return await this.strategyConnectionService.clear(ctx);
         };
     }
 }
@@ -5006,8 +5052,14 @@ class WalkerLogicPrivateService {
         let strategiesTested = 0;
         let bestMetric = null;
         let bestStrategy = null;
+        let pendingStrategy;
         const listenStop = walkerStopSubject
-            .filter((walkerName) => walkerName === context.walkerName)
+            .filter((data) => {
+            let isOk = true;
+            isOk = isOk && data.symbol === symbol;
+            isOk = isOk && data.strategyName === pendingStrategy;
+            return isOk;
+        })
             .map(() => CANCEL_SYMBOL)
             .toPromise();
         // Run backtest for each strategy
@@ -5025,6 +5077,7 @@ class WalkerLogicPrivateService {
                 exchangeName: context.exchangeName,
                 frameName: context.frameName,
             });
+            pendingStrategy = strategyName;
             const result = await Promise.race([
                 await resolveDocuments(iterator),
                 listenStop,
@@ -5040,7 +5093,7 @@ class WalkerLogicPrivateService {
                 symbol,
             });
             // Get statistics from BacktestMarkdownService
-            const stats = await this.backtestMarkdownService.getData(strategyName);
+            const stats = await this.backtestMarkdownService.getData(symbol, strategyName);
             // Extract metric value
             const value = stats[metric];
             const metricValue = value !== null &&
@@ -5099,7 +5152,7 @@ class WalkerLogicPrivateService {
             bestStrategy,
             bestMetric,
             bestStats: bestStrategy !== null
-                ? await this.backtestMarkdownService.getData(bestStrategy)
+                ? await this.backtestMarkdownService.getData(symbol, bestStrategy)
                 : null,
         };
         // Call onComplete callback if provided with final best results
@@ -5655,10 +5708,10 @@ class BacktestMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a strategy.
-         * Each strategy gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
+         * Each symbol-strategy combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$4());
+        this.getStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$4());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -5685,56 +5738,61 @@ class BacktestMarkdownService {
             if (data.action !== "closed") {
                 return;
             }
-            const storage = this.getStorage(data.strategyName);
+            const storage = this.getStorage(data.symbol, data.strategyName);
             storage.addSignal(data);
         };
         /**
-         * Gets statistical data from all closed signals for a strategy.
+         * Gets statistical data from all closed signals for a symbol-strategy pair.
          * Delegates to ReportStorage.getData().
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new BacktestMarkdownService();
-         * const stats = await service.getData("my-strategy");
+         * const stats = await service.getData("BTCUSDT", "my-strategy");
          * console.log(stats.sharpeRatio, stats.winRate);
          * ```
          */
-        this.getData = async (strategyName) => {
+        this.getData = async (symbol, strategyName) => {
             this.loggerService.log("backtestMarkdownService getData", {
+                symbol,
                 strategyName,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(symbol, strategyName);
             return storage.getData();
         };
         /**
-         * Generates markdown report with all closed signals for a strategy.
+         * Generates markdown report with all closed signals for a symbol-strategy pair.
          * Delegates to ReportStorage.generateReport().
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
          * @returns Markdown formatted report string with table of all closed signals
          *
          * @example
          * ```typescript
          * const service = new BacktestMarkdownService();
-         * const markdown = await service.getReport("my-strategy");
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy");
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (strategyName) => {
+        this.getReport = async (symbol, strategyName) => {
             this.loggerService.log("backtestMarkdownService getReport", {
+                symbol,
                 strategyName,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(symbol, strategyName);
             return storage.getReport(strategyName);
         };
         /**
-         * Saves strategy report to disk.
+         * Saves symbol-strategy report to disk.
          * Creates directory if it doesn't exist.
          * Delegates to ReportStorage.dump().
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/backtest")
          *
@@ -5743,43 +5801,50 @@ class BacktestMarkdownService {
          * const service = new BacktestMarkdownService();
          *
          * // Save to default path: ./dump/backtest/my-strategy.md
-         * await service.dump("my-strategy");
+         * await service.dump("BTCUSDT", "my-strategy");
          *
          * // Save to custom path: ./custom/path/my-strategy.md
-         * await service.dump("my-strategy", "./custom/path");
+         * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (strategyName, path = "./dump/backtest") => {
+        this.dump = async (symbol, strategyName, path = "./dump/backtest") => {
             this.loggerService.log("backtestMarkdownService dump", {
+                symbol,
                 strategyName,
                 path,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(symbol, strategyName);
             await storage.dump(strategyName, path);
         };
         /**
          * Clears accumulated signal data from storage.
-         * If strategyName is provided, clears only that strategy's data.
-         * If strategyName is omitted, clears all strategies' data.
+         * If ctx is provided, clears only that specific symbol-strategy pair's data.
+         * If nothing is provided, clears all data.
          *
-         * @param strategyName - Optional strategy name to clear specific strategy data
+         * @param ctx - Optional context with symbol and strategyName
          *
          * @example
          * ```typescript
          * const service = new BacktestMarkdownService();
          *
-         * // Clear specific strategy data
-         * await service.clear("my-strategy");
+         * // Clear specific symbol-strategy pair
+         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy" });
          *
-         * // Clear all strategies' data
+         * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (strategyName) => {
+        this.clear = async (ctx) => {
             this.loggerService.log("backtestMarkdownService clear", {
-                strategyName,
+                ctx,
             });
-            this.getStorage.clear(strategyName);
+            if (ctx) {
+                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                this.getStorage.clear(key);
+            }
+            else {
+                this.getStorage.clear();
+            }
         };
         /**
          * Initializes the service by subscribing to backtest signal events.
@@ -6178,10 +6243,10 @@ class LiveMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a strategy.
-         * Each strategy gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
+         * Each symbol-strategy combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$3());
+        this.getStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$3());
         /**
          * Processes tick events and accumulates all event types.
          * Should be called from IStrategyCallbacks.onTick.
@@ -6207,7 +6272,7 @@ class LiveMarkdownService {
             this.loggerService.log("liveMarkdownService tick", {
                 data,
             });
-            const storage = this.getStorage(data.strategyName);
+            const storage = this.getStorage(data.symbol, data.strategyName);
             if (data.action === "idle") {
                 storage.addIdleEvent(data.currentPrice);
             }
@@ -6222,52 +6287,57 @@ class LiveMarkdownService {
             }
         };
         /**
-         * Gets statistical data from all live trading events for a strategy.
+         * Gets statistical data from all live trading events for a symbol-strategy pair.
          * Delegates to ReportStorage.getData().
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new LiveMarkdownService();
-         * const stats = await service.getData("my-strategy");
+         * const stats = await service.getData("BTCUSDT", "my-strategy");
          * console.log(stats.sharpeRatio, stats.winRate);
          * ```
          */
-        this.getData = async (strategyName) => {
+        this.getData = async (symbol, strategyName) => {
             this.loggerService.log("liveMarkdownService getData", {
+                symbol,
                 strategyName,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(symbol, strategyName);
             return storage.getData();
         };
         /**
-         * Generates markdown report with all events for a strategy.
+         * Generates markdown report with all events for a symbol-strategy pair.
          * Delegates to ReportStorage.getReport().
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
          * @returns Markdown formatted report string with table of all events
          *
          * @example
          * ```typescript
          * const service = new LiveMarkdownService();
-         * const markdown = await service.getReport("my-strategy");
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy");
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (strategyName) => {
+        this.getReport = async (symbol, strategyName) => {
             this.loggerService.log("liveMarkdownService getReport", {
+                symbol,
                 strategyName,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(symbol, strategyName);
             return storage.getReport(strategyName);
         };
         /**
-         * Saves strategy report to disk.
+         * Saves symbol-strategy report to disk.
          * Creates directory if it doesn't exist.
          * Delegates to ReportStorage.dump().
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/live")
          *
@@ -6276,43 +6346,50 @@ class LiveMarkdownService {
          * const service = new LiveMarkdownService();
          *
          * // Save to default path: ./dump/live/my-strategy.md
-         * await service.dump("my-strategy");
+         * await service.dump("BTCUSDT", "my-strategy");
          *
          * // Save to custom path: ./custom/path/my-strategy.md
-         * await service.dump("my-strategy", "./custom/path");
+         * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (strategyName, path = "./dump/live") => {
+        this.dump = async (symbol, strategyName, path = "./dump/live") => {
             this.loggerService.log("liveMarkdownService dump", {
+                symbol,
                 strategyName,
                 path,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(symbol, strategyName);
             await storage.dump(strategyName, path);
         };
         /**
          * Clears accumulated event data from storage.
-         * If strategyName is provided, clears only that strategy's data.
-         * If strategyName is omitted, clears all strategies' data.
+         * If ctx is provided, clears only that specific symbol-strategy pair's data.
+         * If nothing is provided, clears all data.
          *
-         * @param strategyName - Optional strategy name to clear specific strategy data
+         * @param ctx - Optional context with symbol and strategyName
          *
          * @example
          * ```typescript
          * const service = new LiveMarkdownService();
          *
-         * // Clear specific strategy data
-         * await service.clear("my-strategy");
+         * // Clear specific symbol-strategy pair
+         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy" });
          *
-         * // Clear all strategies' data
+         * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (strategyName) => {
+        this.clear = async (ctx) => {
             this.loggerService.log("liveMarkdownService clear", {
-                strategyName,
+                ctx,
             });
-            this.getStorage.clear(strategyName);
+            if (ctx) {
+                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                this.getStorage.clear(key);
+            }
+            else {
+                this.getStorage.clear();
+            }
         };
         /**
          * Initializes the service by subscribing to live signal events.
@@ -6561,10 +6638,10 @@ class ScheduleMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create ReportStorage for a strategy.
-         * Each strategy gets its own isolated storage instance.
+         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
+         * Each symbol-strategy combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new ReportStorage$2());
+        this.getStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$2());
         /**
          * Processes tick events and accumulates scheduled/cancelled events.
          * Should be called from signalLiveEmitter subscription.
@@ -6583,7 +6660,7 @@ class ScheduleMarkdownService {
             this.loggerService.log("scheduleMarkdownService tick", {
                 data,
             });
-            const storage = this.getStorage(data.strategyName);
+            const storage = this.getStorage(data.symbol, data.strategyName);
             if (data.action === "scheduled") {
                 storage.addScheduledEvent(data);
             }
@@ -6592,52 +6669,57 @@ class ScheduleMarkdownService {
             }
         };
         /**
-         * Gets statistical data from all scheduled signal events for a strategy.
+         * Gets statistical data from all scheduled signal events for a symbol-strategy pair.
          * Delegates to ReportStorage.getData().
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
          * @returns Statistical data object with all metrics
          *
          * @example
          * ```typescript
          * const service = new ScheduleMarkdownService();
-         * const stats = await service.getData("my-strategy");
+         * const stats = await service.getData("BTCUSDT", "my-strategy");
          * console.log(stats.cancellationRate, stats.avgWaitTime);
          * ```
          */
-        this.getData = async (strategyName) => {
+        this.getData = async (symbol, strategyName) => {
             this.loggerService.log("scheduleMarkdownService getData", {
+                symbol,
                 strategyName,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(symbol, strategyName);
             return storage.getData();
         };
         /**
-         * Generates markdown report with all scheduled events for a strategy.
+         * Generates markdown report with all scheduled events for a symbol-strategy pair.
          * Delegates to ReportStorage.getReport().
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
          * @returns Markdown formatted report string with table of all events
          *
          * @example
          * ```typescript
          * const service = new ScheduleMarkdownService();
-         * const markdown = await service.getReport("my-strategy");
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy");
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (strategyName) => {
+        this.getReport = async (symbol, strategyName) => {
             this.loggerService.log("scheduleMarkdownService getReport", {
+                symbol,
                 strategyName,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(symbol, strategyName);
             return storage.getReport(strategyName);
         };
         /**
-         * Saves strategy report to disk.
+         * Saves symbol-strategy report to disk.
          * Creates directory if it doesn't exist.
          * Delegates to ReportStorage.dump().
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/schedule")
          *
@@ -6646,43 +6728,50 @@ class ScheduleMarkdownService {
          * const service = new ScheduleMarkdownService();
          *
          * // Save to default path: ./dump/schedule/my-strategy.md
-         * await service.dump("my-strategy");
+         * await service.dump("BTCUSDT", "my-strategy");
          *
          * // Save to custom path: ./custom/path/my-strategy.md
-         * await service.dump("my-strategy", "./custom/path");
+         * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (strategyName, path = "./dump/schedule") => {
+        this.dump = async (symbol, strategyName, path = "./dump/schedule") => {
             this.loggerService.log("scheduleMarkdownService dump", {
+                symbol,
                 strategyName,
                 path,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(symbol, strategyName);
             await storage.dump(strategyName, path);
         };
         /**
          * Clears accumulated event data from storage.
-         * If strategyName is provided, clears only that strategy's data.
-         * If strategyName is omitted, clears all strategies' data.
+         * If ctx is provided, clears only that specific symbol-strategy pair's data.
+         * If nothing is provided, clears all data.
          *
-         * @param strategyName - Optional strategy name to clear specific strategy data
+         * @param ctx - Optional context with symbol and strategyName
          *
          * @example
          * ```typescript
          * const service = new ScheduleMarkdownService();
          *
-         * // Clear specific strategy data
-         * await service.clear("my-strategy");
+         * // Clear specific symbol-strategy pair
+         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy" });
          *
-         * // Clear all strategies' data
+         * // Clear all data
          * await service.clear();
          * ```
          */
-        this.clear = async (strategyName) => {
+        this.clear = async (ctx) => {
             this.loggerService.log("scheduleMarkdownService clear", {
-                strategyName,
+                ctx,
             });
-            this.getStorage.clear(strategyName);
+            if (ctx) {
+                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                this.getStorage.clear(key);
+            }
+            else {
+                this.getStorage.clear();
+            }
         };
         /**
          * Initializes the service by subscribing to live signal events.
@@ -6916,10 +7005,10 @@ class PerformanceMarkdownService {
         /** Logger service for debug output */
         this.loggerService = inject(TYPES.loggerService);
         /**
-         * Memoized function to get or create PerformanceStorage for a strategy.
-         * Each strategy gets its own isolated storage instance.
+         * Memoized function to get or create PerformanceStorage for a symbol-strategy pair.
+         * Each symbol-strategy combination gets its own isolated storage instance.
          */
-        this.getStorage = memoize(([strategyName]) => `${strategyName}`, () => new PerformanceStorage());
+        this.getStorage = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new PerformanceStorage());
         /**
          * Processes performance events and accumulates metrics.
          * Should be called from performance tracking code.
@@ -6930,83 +7019,97 @@ class PerformanceMarkdownService {
             this.loggerService.log("performanceMarkdownService track", {
                 event,
             });
+            const symbol = event.symbol || "global";
             const strategyName = event.strategyName || "global";
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(symbol, strategyName);
             storage.addEvent(event);
         };
         /**
-         * Gets aggregated performance statistics for a strategy.
+         * Gets aggregated performance statistics for a symbol-strategy pair.
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
          * @returns Performance statistics with aggregated metrics
          *
          * @example
          * ```typescript
-         * const stats = await performanceService.getData("my-strategy");
+         * const stats = await performanceService.getData("BTCUSDT", "my-strategy");
          * 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 (strategyName) => {
+        this.getData = async (symbol, strategyName) => {
             this.loggerService.log("performanceMarkdownService getData", {
+                symbol,
                 strategyName,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(symbol, strategyName);
             return storage.getData(strategyName);
         };
         /**
          * Generates markdown report with performance analysis.
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
          * @returns Markdown formatted report string
          *
          * @example
          * ```typescript
-         * const markdown = await performanceService.getReport("my-strategy");
+         * const markdown = await performanceService.getReport("BTCUSDT", "my-strategy");
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (strategyName) => {
+        this.getReport = async (symbol, strategyName) => {
             this.loggerService.log("performanceMarkdownService getReport", {
+                symbol,
                 strategyName,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(symbol, strategyName);
             return storage.getReport(strategyName);
         };
         /**
          * Saves performance report to disk.
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report
          *
          * @example
          * ```typescript
          * // Save to default path: ./dump/performance/my-strategy.md
-         * await performanceService.dump("my-strategy");
+         * await performanceService.dump("BTCUSDT", "my-strategy");
          *
          * // Save to custom path
-         * await performanceService.dump("my-strategy", "./custom/path");
+         * await performanceService.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (strategyName, path = "./dump/performance") => {
+        this.dump = async (symbol, strategyName, path = "./dump/performance") => {
             this.loggerService.log("performanceMarkdownService dump", {
+                symbol,
                 strategyName,
                 path,
             });
-            const storage = this.getStorage(strategyName);
+            const storage = this.getStorage(symbol, strategyName);
             await storage.dump(strategyName, path);
         };
         /**
          * Clears accumulated performance data from storage.
          *
-         * @param strategyName - Optional strategy name to clear specific strategy data
+         * @param symbol - Optional trading pair symbol
+         * @param strategyName - Optional strategy name
          */
-        this.clear = async (strategyName) => {
+        this.clear = async (ctx) => {
             this.loggerService.log("performanceMarkdownService clear", {
-                strategyName,
+                ctx,
             });
-            this.getStorage.clear(strategyName);
+            if (ctx) {
+                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                this.getStorage.clear(key);
+            }
+            {
+                this.getStorage.clear();
+            }
         };
         /**
          * Initializes the service by subscribing to performance events.
@@ -8700,7 +8803,7 @@ class OptimizerTemplateService {
         };
         /**
          * Generates text() helper for LLM text generation.
-         * Uses Ollama gpt-oss:20b model for market analysis.
+         * Uses Ollama deepseek-v3.1:671b model for market analysis.
          *
          * @param symbol - Trading pair symbol (used in prompt)
          * @returns Generated async text() function
@@ -8725,7 +8828,7 @@ class OptimizerTemplateService {
                 `    });`,
                 ``,
                 `    const response = await ollama.chat({`,
-                `        model: "gpt-oss:20b",`,
+                `        model: "deepseek-v3.1:671b",`,
                 `        messages: [`,
                 `            {`,
                 `                role: "system",`,
@@ -8790,7 +8893,7 @@ class OptimizerTemplateService {
                 `    });`,
                 ``,
                 `    const response = await ollama.chat({`,
-                `        model: "gpt-oss:20b",`,
+                `        model: "deepseek-v3.1:671b",`,
                 `        messages: [`,
                 `            {`,
                 `                role: "system",`,
@@ -12301,11 +12404,11 @@ class BacktestUtils {
                 context,
             });
             {
-                backtest$1.backtestMarkdownService.clear(context.strategyName);
-                backtest$1.scheduleMarkdownService.clear(context.strategyName);
+                backtest$1.backtestMarkdownService.clear({ symbol, strategyName: context.strategyName });
+                backtest$1.scheduleMarkdownService.clear({ symbol, strategyName: context.strategyName });
             }
             {
-                backtest$1.strategyGlobalService.clear(context.strategyName);
+                backtest$1.strategyGlobalService.clear({ symbol, strategyName: context.strategyName });
             }
             {
                 const { riskName } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -12359,9 +12462,9 @@ class BacktestUtils {
             };
             task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
             return () => {
-                backtest$1.strategyGlobalService.stop(context.strategyName);
+                backtest$1.strategyGlobalService.stop(symbol, context.strategyName);
                 backtest$1.strategyGlobalService
-                    .getPendingSignal(context.strategyName)
+                    .getPendingSignal(symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
                         return;
@@ -12380,40 +12483,44 @@ class BacktestUtils {
             };
         };
         /**
-         * Gets statistical data from all closed signals for a strategy.
+         * 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
          * @returns Promise resolving to statistical data object
          *
          * @example
          * ```typescript
-         * const stats = await Backtest.getData("my-strategy");
+         * const stats = await Backtest.getData("BTCUSDT", "my-strategy");
          * console.log(stats.sharpeRatio, stats.winRate);
          * ```
          */
-        this.getData = async (strategyName) => {
+        this.getData = async (symbol, strategyName) => {
             backtest$1.loggerService.info("BacktestUtils.getData", {
+                symbol,
                 strategyName,
             });
-            return await backtest$1.backtestMarkdownService.getData(strategyName);
+            return await backtest$1.backtestMarkdownService.getData(symbol, strategyName);
         };
         /**
-         * Generates markdown report with all closed signals for a strategy.
+         * 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
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
          * ```typescript
-         * const markdown = await Backtest.getReport("my-strategy");
+         * const markdown = await Backtest.getReport("BTCUSDT", "my-strategy");
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (strategyName) => {
+        this.getReport = async (symbol, strategyName) => {
             backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_REPORT, {
+                symbol,
                 strategyName,
             });
-            return await backtest$1.backtestMarkdownService.getReport(strategyName);
+            return await backtest$1.backtestMarkdownService.getReport(symbol, strategyName);
         };
         /**
          * Saves strategy report to disk.
@@ -12510,11 +12617,11 @@ class LiveUtils {
                 context,
             });
             {
-                backtest$1.liveMarkdownService.clear(context.strategyName);
-                backtest$1.scheduleMarkdownService.clear(context.strategyName);
+                backtest$1.liveMarkdownService.clear({ symbol, strategyName: context.strategyName });
+                backtest$1.scheduleMarkdownService.clear({ symbol, strategyName: context.strategyName });
             }
             {
-                backtest$1.strategyGlobalService.clear(context.strategyName);
+                backtest$1.strategyGlobalService.clear({ symbol, strategyName: context.strategyName });
             }
             {
                 const { riskName } = backtest$1.strategySchemaService.get(context.strategyName);
@@ -12568,9 +12675,9 @@ class LiveUtils {
             };
             task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
             return () => {
-                backtest$1.strategyGlobalService.stop(context.strategyName);
+                backtest$1.strategyGlobalService.stop(symbol, context.strategyName);
                 backtest$1.strategyGlobalService
-                    .getPendingSignal(context.strategyName)
+                    .getPendingSignal(symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
                         return;
@@ -12589,40 +12696,44 @@ class LiveUtils {
             };
         };
         /**
-         * Gets statistical data from all live trading events for a strategy.
+         * 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
          * @returns Promise resolving to statistical data object
          *
          * @example
          * ```typescript
-         * const stats = await Live.getData("my-strategy");
+         * const stats = await Live.getData("BTCUSDT", "my-strategy");
          * console.log(stats.sharpeRatio, stats.winRate);
          * ```
          */
-        this.getData = async (strategyName) => {
+        this.getData = async (symbol, strategyName) => {
             backtest$1.loggerService.info("LiveUtils.getData", {
+                symbol,
                 strategyName,
             });
-            return await backtest$1.liveMarkdownService.getData(strategyName);
+            return await backtest$1.liveMarkdownService.getData(symbol, strategyName);
         };
         /**
-         * Generates markdown report with all events for a strategy.
+         * Generates markdown report with all events for a symbol-strategy pair.
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
          * ```typescript
-         * const markdown = await Live.getReport("my-strategy");
+         * const markdown = await Live.getReport("BTCUSDT", "my-strategy");
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (strategyName) => {
+        this.getReport = async (symbol, strategyName) => {
             backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_REPORT, {
+                symbol,
                 strategyName,
             });
-            return await backtest$1.liveMarkdownService.getReport(strategyName);
+            return await backtest$1.liveMarkdownService.getReport(symbol, strategyName);
         };
         /**
          * Saves strategy report to disk.
@@ -12696,40 +12807,44 @@ const SCHEDULE_METHOD_NAME_DUMP = "ScheduleUtils.dump";
 class ScheduleUtils {
     constructor() {
         /**
-         * Gets statistical data from all scheduled signal events for a strategy.
+         * Gets statistical data from all scheduled signal events for a symbol-strategy pair.
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to get data for
          * @returns Promise resolving to statistical data object
          *
          * @example
          * ```typescript
-         * const stats = await Schedule.getData("my-strategy");
+         * const stats = await Schedule.getData("BTCUSDT", "my-strategy");
          * console.log(stats.cancellationRate, stats.avgWaitTime);
          * ```
          */
-        this.getData = async (strategyName) => {
+        this.getData = async (symbol, strategyName) => {
             backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_GET_DATA, {
+                symbol,
                 strategyName,
             });
-            return await backtest$1.scheduleMarkdownService.getData(strategyName);
+            return await backtest$1.scheduleMarkdownService.getData(symbol, strategyName);
         };
         /**
-         * Generates markdown report with all scheduled events for a strategy.
+         * Generates markdown report with all scheduled events for a symbol-strategy pair.
          *
+         * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
          * ```typescript
-         * const markdown = await Schedule.getReport("my-strategy");
+         * const markdown = await Schedule.getReport("BTCUSDT", "my-strategy");
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (strategyName) => {
+        this.getReport = async (symbol, strategyName) => {
             backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_GET_REPORT, {
+                symbol,
                 strategyName,
             });
-            return await backtest$1.scheduleMarkdownService.getReport(strategyName);
+            return await backtest$1.scheduleMarkdownService.getReport(symbol, strategyName);
         };
         /**
          * Saves strategy report to disk.
@@ -12801,19 +12916,20 @@ const Schedule = new ScheduleUtils();
  */
 class Performance {
     /**
-     * Gets aggregated performance statistics for a strategy.
+     * Gets aggregated performance statistics for a symbol-strategy pair.
      *
      * Returns detailed metrics grouped by operation type:
      * - Count, total duration, average, min, max
      * - Standard deviation for volatility
      * - Percentiles (median, P95, P99) for outlier detection
      *
+     * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name to analyze
      * @returns Performance statistics with aggregated metrics
      *
      * @example
      * ```typescript
-     * const stats = await Performance.getData("my-strategy");
+     * const stats = await Performance.getData("BTCUSDT", "my-strategy");
      *
      * // Find slowest operation type
      * const slowest = Object.values(stats.metricStats)
@@ -12828,8 +12944,8 @@ class Performance {
      * }
      * ```
      */
-    static async getData(strategyName) {
-        return backtest$1.performanceMarkdownService.getData(strategyName);
+    static async getData(symbol, strategyName) {
+        return backtest$1.performanceMarkdownService.getData(symbol, strategyName);
     }
     /**
      * Generates markdown report with performance analysis.
@@ -12839,12 +12955,13 @@ class Performance {
      * - Detailed metrics table with statistics
      * - Percentile analysis for bottleneck detection
      *
+     * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name to generate report for
      * @returns Markdown formatted report string
      *
      * @example
      * ```typescript
-     * const markdown = await Performance.getReport("my-strategy");
+     * const markdown = await Performance.getReport("BTCUSDT", "my-strategy");
      * console.log(markdown);
      *
      * // Or save to file
@@ -12852,8 +12969,8 @@ class Performance {
      * await fs.writeFile("performance-report.md", markdown);
      * ```
      */
-    static async getReport(strategyName) {
-        return backtest$1.performanceMarkdownService.getReport(strategyName);
+    static async getReport(symbol, strategyName) {
+        return backtest$1.performanceMarkdownService.getReport(symbol, strategyName);
     }
     /**
      * Saves performance report to disk.
@@ -12876,23 +12993,6 @@ class Performance {
     static async dump(strategyName, path = "./dump/performance") {
         return backtest$1.performanceMarkdownService.dump(strategyName, path);
     }
-    /**
-     * Clears accumulated performance metrics from memory.
-     *
-     * @param strategyName - Optional strategy name to clear specific strategy's metrics
-     *
-     * @example
-     * ```typescript
-     * // Clear specific strategy metrics
-     * await Performance.clear("my-strategy");
-     *
-     * // Clear all metrics for all strategies
-     * await Performance.clear();
-     * ```
-     */
-    static async clear(strategyName) {
-        return backtest$1.performanceMarkdownService.clear(strategyName);
-    }
 }
 
 const WALKER_METHOD_NAME_RUN = "WalkerUtils.run";
@@ -12944,11 +13044,11 @@ class WalkerUtils {
             // Clear backtest data for all strategies
             for (const strategyName of walkerSchema.strategies) {
                 {
-                    backtest$1.backtestMarkdownService.clear(strategyName);
-                    backtest$1.scheduleMarkdownService.clear(strategyName);
+                    backtest$1.backtestMarkdownService.clear({ symbol, strategyName });
+                    backtest$1.scheduleMarkdownService.clear({ symbol, strategyName });
                 }
                 {
-                    backtest$1.strategyGlobalService.clear(strategyName);
+                    backtest$1.strategyGlobalService.clear({ symbol, strategyName });
                 }
                 {
                     const { riskName } = backtest$1.strategySchemaService.get(strategyName);
@@ -13007,9 +13107,9 @@ class WalkerUtils {
             task().catch((error) => errorEmitter.next(new Error(getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
-                    backtest$1.strategyGlobalService.stop(strategyName);
+                    backtest$1.strategyGlobalService.stop(symbol, strategyName);
+                    walkerStopSubject.next({ symbol, strategyName });
                 }
-                walkerStopSubject.next(context.walkerName);
                 if (!isDone) {
                     doneWalkerSubject.next({
                         exchangeName: walkerSchema.exchangeName,