backtest-kit 1.5.26 → 1.5.27

package/build/index.cjs

@@ -2628,7 +2628,7 @@ const PersistScheduleAdapter = new PersistScheduleUtils();
  * Utility class for managing partial profit/loss levels persistence.
  *
  * Features:
- * - Memoized storage instances per symbol
+ * - Memoized storage instances per symbol:strategyName
  * - Custom adapter support
  * - Atomic read/write operations for partial data
  * - Crash-safe partial state management
@@ -2638,23 +2638,25 @@ const PersistScheduleAdapter = new PersistScheduleUtils();
 class PersistPartialUtils {
     constructor() {
         this.PersistPartialFactory = PersistBase;
-        this.getPartialStorage = functoolsKit.memoize(([symbol]) => `${symbol}`, (symbol) => Reflect.construct(this.PersistPartialFactory, [
-            symbol,
+        this.getPartialStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => Reflect.construct(this.PersistPartialFactory, [
+            `${symbol}_${strategyName}`,
             `./dump/data/partial/`,
         ]));
         /**
-         * Reads persisted partial data for a symbol.
+         * Reads persisted partial data for a symbol and strategy.
          *
          * Called by ClientPartial.waitForInit() to restore state.
          * Returns empty object if no partial data exists.
          *
          * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
          * @returns Promise resolving to partial data record
          */
-        this.readPartialData = async (symbol) => {
+        this.readPartialData = async (symbol, strategyName) => {
             backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
-            const isInitial = !this.getPartialStorage.has(symbol);
-            const stateStorage = this.getPartialStorage(symbol);
+            const key = `${symbol}:${strategyName}`;
+            const isInitial = !this.getPartialStorage.has(key);
+            const stateStorage = this.getPartialStorage(symbol, strategyName);
             await stateStorage.waitForInit(isInitial);
             const PARTIAL_STORAGE_KEY = "levels";
             if (await stateStorage.hasValue(PARTIAL_STORAGE_KEY)) {
@@ -2670,12 +2672,14 @@ class PersistPartialUtils {
          *
          * @param partialData - Record of signal IDs to partial data
          * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
          * @returns Promise that resolves when write is complete
          */
-        this.writePartialData = async (partialData, symbol) => {
+        this.writePartialData = async (partialData, symbol, strategyName) => {
             backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
-            const isInitial = !this.getPartialStorage.has(symbol);
-            const stateStorage = this.getPartialStorage(symbol);
+            const key = `${symbol}:${strategyName}`;
+            const isInitial = !this.getPartialStorage.has(key);
+            const stateStorage = this.getPartialStorage(symbol, strategyName);
             await stateStorage.waitForInit(isInitial);
             const PARTIAL_STORAGE_KEY = "levels";
             await stateStorage.writeValue(PARTIAL_STORAGE_KEY, partialData);
@@ -2710,10 +2714,10 @@ class PersistPartialUtils {
  * PersistPartialAdapter.usePersistPartialAdapter(RedisPersist);
  *
  * // Read partial data
- * const partialData = await PersistPartialAdapter.readPartialData("BTCUSDT");
+ * const partialData = await PersistPartialAdapter.readPartialData("BTCUSDT", "my-strategy");
  *
  * // Write partial data
- * await PersistPartialAdapter.writePartialData(partialData, "BTCUSDT");
+ * await PersistPartialAdapter.writePartialData(partialData, "BTCUSDT", "my-strategy");
  * ```
  */
 const PersistPartialAdapter = new PersistPartialUtils();
@@ -4574,25 +4578,25 @@ const NOOP_RISK = {
     addSignal: () => Promise.resolve(),
     removeSignal: () => Promise.resolve(),
 };
-const GET_RISK_FN = (dto, self) => {
+const GET_RISK_FN = (dto, backtest, self) => {
     const hasRiskName = !!dto.riskName;
-    const hasRiskList = !!(dto.riskList?.length);
+    const hasRiskList = !!dto.riskList?.length;
     // Нет ни riskName, ни riskList
     if (!hasRiskName && !hasRiskList) {
         return NOOP_RISK;
     }
     // Есть только riskName (без riskList)
     if (hasRiskName && !hasRiskList) {
-        return self.riskConnectionService.getRisk(dto.riskName);
+        return self.riskConnectionService.getRisk(dto.riskName, backtest);
     }
     // Есть только riskList (без riskName)
     if (!hasRiskName && hasRiskList) {
-        return new MergeRisk(dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName)));
+        return new MergeRisk(dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName, backtest)));
     }
     // Есть и riskName, и riskList - объединяем (riskName в начало)
     return new MergeRisk([
-        self.riskConnectionService.getRisk(dto.riskName),
-        ...dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName))
+        self.riskConnectionService.getRisk(dto.riskName, backtest),
+        ...dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName, backtest)),
     ]);
 };
 /**
@@ -4634,7 +4638,7 @@ class StrategyConnectionService {
          * @param strategyName - Name of registered strategy schema
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => {
+        this.getStrategy = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, (symbol, strategyName, backtest) => {
             const { riskName = "", riskList = [], getSignal, interval, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
@@ -4647,7 +4651,7 @@ class StrategyConnectionService {
                 risk: GET_RISK_FN({
                     riskName,
                     riskList,
-                }, this),
+                }, backtest, this),
                 riskName,
                 strategyName,
                 getSignal,
@@ -4664,12 +4668,13 @@ class StrategyConnectionService {
          *
          * @returns Promise resolving to pending signal or null
          */
-        this.getPendingSignal = async (symbol, strategyName) => {
+        this.getPendingSignal = async (backtest, symbol, strategyName) => {
             this.loggerService.log("strategyConnectionService getPendingSignal", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const strategy = this.getStrategy(symbol, strategyName);
+            const strategy = this.getStrategy(symbol, strategyName, backtest);
             return await strategy.getPendingSignal(symbol, strategyName);
         };
         /**
@@ -4682,12 +4687,13 @@ class StrategyConnectionService {
          * @param strategyName - Name of the strategy
          * @returns Promise resolving to true if strategy is stopped, false otherwise
          */
-        this.getStopped = async (symbol, strategyName) => {
+        this.getStopped = async (backtest, symbol, strategyName) => {
             this.loggerService.log("strategyConnectionService getStopped", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const strategy = this.getStrategy(symbol, strategyName);
+            const strategy = this.getStrategy(symbol, strategyName, backtest);
             return await strategy.getStopped(symbol, strategyName);
         };
         /**
@@ -4705,7 +4711,8 @@ class StrategyConnectionService {
                 symbol,
                 strategyName,
             });
-            const strategy = this.getStrategy(symbol, strategyName);
+            const backtest = this.executionContextService.context.backtest;
+            const strategy = this.getStrategy(symbol, strategyName, backtest);
             await strategy.waitForInit();
             const tick = await strategy.tick(symbol, strategyName);
             {
@@ -4736,7 +4743,8 @@ class StrategyConnectionService {
                 strategyName,
                 candleCount: candles.length,
             });
-            const strategy = this.getStrategy(symbol, strategyName);
+            const backtest = this.executionContextService.context.backtest;
+            const strategy = this.getStrategy(symbol, strategyName, backtest);
             await strategy.waitForInit();
             const tick = await strategy.backtest(symbol, strategyName, candles);
             {
@@ -4757,11 +4765,11 @@ class StrategyConnectionService {
          * @param strategyName - Name of strategy to stop
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (ctx, backtest) => {
+        this.stop = async (backtest, ctx) => {
             this.loggerService.log("strategyConnectionService stop", {
                 ctx,
             });
-            const strategy = this.getStrategy(ctx.symbol, ctx.strategyName);
+            const strategy = this.getStrategy(ctx.symbol, ctx.strategyName, backtest);
             await strategy.stop(ctx.symbol, ctx.strategyName, backtest);
         };
         /**
@@ -4772,12 +4780,12 @@ class StrategyConnectionService {
          *
          * @param ctx - Optional context with symbol and strategyName (clears all if not provided)
          */
-        this.clear = async (ctx) => {
+        this.clear = async (backtest, ctx) => {
             this.loggerService.log("strategyConnectionService clear", {
                 ctx,
             });
             if (ctx) {
-                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                const key = `${ctx.symbol}:${ctx.strategyName}:${backtest ? "backtest" : "live"}`;
                 this.getStrategy.clear(key);
             }
             else {
@@ -5172,9 +5180,15 @@ const DO_VALIDATION_FN = functoolsKit.trycatch(async (validation, params) => {
  * Initializes active positions by reading from persistence.
  * Uses singleshot pattern to ensure it only runs once.
  * This function is exported for use in tests or other modules.
+ *
+ * In backtest mode, initializes with empty Map. In live mode, reads from persist storage.
  */
 const WAIT_FOR_INIT_FN$1 = async (self) => {
-    self.params.logger.debug("ClientRisk waitForInit");
+    self.params.logger.debug("ClientRisk waitForInit", { backtest: self.params.backtest });
+    if (self.params.backtest) {
+        self._activePositions = new Map();
+        return;
+    }
     const persistedPositions = await PersistRiskAdapter.readPositionData(self.params.riskName);
     self._activePositions = new Map(persistedPositions);
 };
@@ -5222,6 +5236,7 @@ class ClientRisk {
             this.params.logger.debug("ClientRisk checkSignal", {
                 symbol: params.symbol,
                 strategyName: params.strategyName,
+                backtest: this.params.backtest,
             });
             if (this._activePositions === POSITION_NEED_FETCH) {
                 await this.waitForInit();
@@ -5267,8 +5282,12 @@ class ClientRisk {
     }
     /**
      * Persists current active positions to disk.
+     * Skips in backtest mode.
      */
     async _updatePositions() {
+        if (this.params.backtest) {
+            return;
+        }
         if (this._activePositions === POSITION_NEED_FETCH) {
             await this.waitForInit();
         }
@@ -5282,6 +5301,7 @@ class ClientRisk {
         this.params.logger.debug("ClientRisk addSignal", {
             symbol,
             context,
+            backtest: this.params.backtest,
         });
         if (this._activePositions === POSITION_NEED_FETCH) {
             await this.waitForInit();
@@ -5304,6 +5324,7 @@ class ClientRisk {
         this.params.logger.debug("ClientRisk removeSignal", {
             symbol,
             context,
+            backtest: this.params.backtest,
         });
         if (this._activePositions === POSITION_NEED_FETCH) {
             await this.waitForInit();
@@ -5374,19 +5395,21 @@ class RiskConnectionService {
         this.loggerService = inject(TYPES.loggerService);
         this.riskSchemaService = inject(TYPES.riskSchemaService);
         /**
-         * Retrieves memoized ClientRisk instance for given risk name.
+         * Retrieves memoized ClientRisk instance for given risk name and backtest mode.
          *
          * Creates ClientRisk on first call, returns cached instance on subsequent calls.
-         * Cache key is riskName string.
+         * Cache key is "riskName:backtest" string to separate live and backtest instances.
          *
          * @param riskName - Name of registered risk schema
+         * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientRisk instance
          */
-        this.getRisk = functoolsKit.memoize(([riskName]) => `${riskName}`, (riskName) => {
+        this.getRisk = functoolsKit.memoize(([riskName, backtest]) => `${riskName}:${backtest ? "backtest" : "live"}`, (riskName, backtest) => {
             const schema = this.riskSchemaService.get(riskName);
             return new ClientRisk({
                 ...schema,
                 logger: this.loggerService,
+                backtest,
                 onRejected: COMMIT_REJECTION_FN,
             });
         });
@@ -5398,7 +5421,7 @@ 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
+         * @param context - Execution context with risk name and backtest mode
          * @returns Promise resolving to risk check result
          */
         this.checkSignal = async (params, context) => {
@@ -5406,46 +5429,48 @@ class RiskConnectionService {
                 symbol: params.symbol,
                 context,
             });
-            return await this.getRisk(context.riskName).checkSignal(params);
+            return await this.getRisk(context.riskName, context.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)
+         * @param context - Context information (strategyName, riskName, backtest)
          */
         this.addSignal = async (symbol, context) => {
             this.loggerService.log("riskConnectionService addSignal", {
                 symbol,
                 context,
             });
-            await this.getRisk(context.riskName).addSignal(symbol, context);
+            await this.getRisk(context.riskName, context.backtest).addSignal(symbol, context);
         };
         /**
          * 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)
+         * @param context - Context information (strategyName, riskName, backtest)
          */
         this.removeSignal = async (symbol, context) => {
             this.loggerService.log("riskConnectionService removeSignal", {
                 symbol,
                 context,
             });
-            await this.getRisk(context.riskName).removeSignal(symbol, context);
+            await this.getRisk(context.riskName, context.backtest).removeSignal(symbol, context);
         };
         /**
          * Clears the cached ClientRisk instance for the given risk name.
          *
          * @param riskName - Name of the risk schema to clear from cache
          */
-        this.clear = async (riskName) => {
+        this.clear = async (backtest, riskName) => {
             this.loggerService.log("riskConnectionService clear", {
                 riskName,
+                backtest,
             });
-            this.getRisk.clear(riskName);
+            const key = `${riskName}:${backtest ? "backtest" : "live"}`;
+            this.getRisk.clear(key);
         };
     }
 }
@@ -5668,7 +5693,7 @@ class StrategyCoreService {
          * @param strategyName - Name of the strategy
          * @returns Promise resolving to pending signal or null
          */
-        this.getPendingSignal = async (symbol, strategyName) => {
+        this.getPendingSignal = async (backtest, symbol, strategyName) => {
             this.loggerService.log("strategyCoreService getPendingSignal", {
                 symbol,
                 strategyName,
@@ -5677,7 +5702,7 @@ class StrategyCoreService {
                 throw new Error("strategyCoreService getPendingSignal requires a method context");
             }
             await this.validate(symbol, strategyName);
-            return await this.strategyConnectionService.getPendingSignal(symbol, strategyName);
+            return await this.strategyConnectionService.getPendingSignal(backtest, symbol, strategyName);
         };
         /**
          * Checks if the strategy has been stopped.
@@ -5689,16 +5714,17 @@ class StrategyCoreService {
          * @param strategyName - Name of the strategy
          * @returns Promise resolving to true if strategy is stopped, false otherwise
          */
-        this.getStopped = async (symbol, strategyName) => {
+        this.getStopped = async (backtest, symbol, strategyName) => {
             this.loggerService.log("strategyCoreService getStopped", {
                 symbol,
                 strategyName,
+                backtest,
             });
             if (!MethodContextService.hasContext()) {
                 throw new Error("strategyCoreService getStopped requires a method context");
             }
             await this.validate(symbol, strategyName);
-            return await this.strategyConnectionService.getStopped(symbol, strategyName);
+            return await this.strategyConnectionService.getStopped(backtest, symbol, strategyName);
         };
         /**
          * Checks signal status at a specific timestamp.
@@ -5772,13 +5798,13 @@ class StrategyCoreService {
          * @param strategyName - Name of strategy to stop
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (ctx, backtest) => {
+        this.stop = async (backtest, ctx) => {
             this.loggerService.log("strategyCoreService stop", {
                 ctx,
                 backtest,
             });
             await this.validate(ctx.symbol, ctx.strategyName);
-            return await this.strategyConnectionService.stop(ctx, backtest);
+            return await this.strategyConnectionService.stop(backtest, ctx);
         };
         /**
          * Clears the memoized ClientStrategy instance from cache.
@@ -5788,14 +5814,14 @@ class StrategyCoreService {
          *
          * @param ctx - Optional context with symbol and strategyName (clears all if not provided)
          */
-        this.clear = async (ctx) => {
+        this.clear = async (backtest, ctx) => {
             this.loggerService.log("strategyCoreService clear", {
                 ctx,
             });
             if (ctx) {
                 await this.validate(ctx.symbol, ctx.strategyName);
             }
-            return await this.strategyConnectionService.clear(ctx);
+            return await this.strategyConnectionService.clear(backtest, ctx);
         };
     }
 }
@@ -5936,14 +5962,15 @@ class RiskGlobalService {
          * If no riskName is provided, clears all risk data.
          * @param riskName - Optional name of the risk instance to clear
          */
-        this.clear = async (riskName) => {
+        this.clear = async (backtest, riskName) => {
             this.loggerService.log("riskGlobalService clear", {
                 riskName,
+                backtest,
             });
             if (riskName) {
                 await this.validate(riskName);
             }
-            return await this.riskConnectionService.clear(riskName);
+            return await this.riskConnectionService.clear(backtest, riskName);
         };
     }
 }
@@ -6487,7 +6514,7 @@ class BacktestLogicPrivateService {
                 });
             }
             // Check if strategy should stop before processing next frame
-            if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+            if (await this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName)) {
                 this.loggerService.info("backtestLogicPrivateService stopped by user request (before tick)", {
                     symbol,
                     when: when.toISOString(),
@@ -6512,7 +6539,7 @@ class BacktestLogicPrivateService {
                 continue;
             }
             // Check if strategy should stop when idle (no active signal)
-            if (await functoolsKit.and(Promise.resolve(result.action === "idle"), this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+            if (await functoolsKit.and(Promise.resolve(result.action === "idle"), this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName))) {
                 this.loggerService.info("backtestLogicPrivateService stopped by user request (idle state)", {
                     symbol,
                     when: when.toISOString(),
@@ -6614,7 +6641,7 @@ class BacktestLogicPrivateService {
                 }
                 yield backtestResult;
                 // Check if strategy should stop after signal is closed
-                if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName)) {
                     this.loggerService.info("backtestLogicPrivateService stopped by user request (after scheduled signal closed)", {
                         symbol,
                         signalId: backtestResult.signal.id,
@@ -6707,7 +6734,7 @@ class BacktestLogicPrivateService {
                 }
                 yield backtestResult;
                 // Check if strategy should stop after signal is closed
-                if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName)) {
                     this.loggerService.info("backtestLogicPrivateService stopped by user request (after signal closed)", {
                         symbol,
                         signalId: backtestResult.signal.id,
@@ -6850,7 +6877,7 @@ class LiveLogicPrivateService {
             previousEventTimestamp = currentTimestamp;
             // Check if strategy should stop when idle (no active signal)
             if (result.action === "idle") {
-                if (await functoolsKit.and(Promise.resolve(true), this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+                if (await functoolsKit.and(Promise.resolve(true), this.strategyCoreService.getStopped(false, symbol, this.methodContextService.context.strategyName))) {
                     this.loggerService.info("liveLogicPrivateService stopped by user request (idle state)", {
                         symbol,
                         when: when.toISOString(),
@@ -6872,7 +6899,7 @@ class LiveLogicPrivateService {
             yield result;
             // Check if strategy should stop after signal is closed
             if (result.action === "closed") {
-                if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(false, symbol, this.methodContextService.context.strategyName)) {
                     this.loggerService.info("liveLogicPrivateService stopped by user request (after signal closed)", {
                         symbol,
                         signalId: result.signal.id,
@@ -11667,6 +11694,9 @@ const HANDLE_PROFIT_FN = async (symbol, data, currentPrice, revenuePercent, back
     if (self._states === NEED_FETCH) {
         throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
     }
+    if (data.id !== self.params.signalId) {
+        throw new Error(`Signal ID mismatch: expected ${self.params.signalId}, got ${data.id}`);
+    }
     let state = self._states.get(data.id);
     if (!state) {
         state = {
@@ -11691,7 +11721,7 @@ const HANDLE_PROFIT_FN = async (symbol, data, currentPrice, revenuePercent, back
         }
     }
     if (shouldPersist) {
-        await self._persistState(symbol, backtest);
+        await self._persistState(symbol, data.strategyName);
     }
 };
 /**
@@ -11713,6 +11743,9 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
     if (self._states === NEED_FETCH) {
         throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
     }
+    if (data.id !== self.params.signalId) {
+        throw new Error(`Signal ID mismatch: expected ${self.params.signalId}, got ${data.id}`);
+    }
     let state = self._states.get(data.id);
     if (!state) {
         state = {
@@ -11738,7 +11771,7 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
         }
     }
     if (shouldPersist) {
-        await self._persistState(symbol, backtest);
+        await self._persistState(symbol, data.strategyName);
     }
 };
 /**
@@ -11747,15 +11780,29 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
  * Loads persisted partial state from disk and restores in-memory Maps.
  * Converts serialized arrays back to Sets for O(1) lookups.
  *
+ * ONLY runs in LIVE mode (backtest=false). In backtest mode, state is not persisted.
+ *
  * @param symbol - Trading pair symbol
+ * @param strategyName - Strategy identifier
+ * @param backtest - True if backtest mode, false if live mode
  * @param self - ClientPartial instance reference
  */
-const WAIT_FOR_INIT_FN = async (symbol, self) => {
-    self.params.logger.debug("ClientPartial waitForInit", { symbol });
-    if (self._states === NEED_FETCH) {
-        throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
+const WAIT_FOR_INIT_FN = async (symbol, strategyName, self) => {
+    self.params.logger.debug("ClientPartial waitForInit", {
+        symbol,
+        strategyName,
+        backtest: self.params.backtest
+    });
+    if (self._states !== NEED_FETCH) {
+        throw new Error("ClientPartial WAIT_FOR_INIT_FN should be called once!");
+    }
+    self._states = new Map();
+    // Skip persistence in backtest mode
+    if (self.params.backtest) {
+        self.params.logger.debug("ClientPartial waitForInit: skipping persist read in backtest mode");
+        return;
     }
-    const partialData = await PersistPartialAdapter.readPartialData(symbol);
+    const partialData = await PersistPartialAdapter.readPartialData(symbol, strategyName);
     for (const [signalId, data] of Object.entries(partialData)) {
         const state = {
             profitLevels: new Set(data.profitLevels),
@@ -11765,6 +11812,7 @@ const WAIT_FOR_INIT_FN = async (symbol, self) => {
     }
     self.params.logger.info("ClientPartial restored state", {
         symbol,
+        strategyName,
         signalCount: Object.keys(partialData).length,
     });
 };
@@ -11843,23 +11891,24 @@ class ClientPartial {
         /**
          * Initializes partial state by loading from disk.
          *
-         * Uses singleshot pattern to ensure initialization happens exactly once per symbol.
+         * Uses singleshot pattern to ensure initialization happens exactly once per symbol:strategyName.
          * Reads persisted state from PersistPartialAdapter and restores to _states Map.
          *
          * Must be called before profit()/loss()/clear() methods.
          *
          * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param backtest - True if backtest mode, false if live mode
          * @returns Promise that resolves when initialization is complete
          *
          * @example
          * ```typescript
          * const partial = new ClientPartial(params);
-         * await partial.waitForInit("BTCUSDT"); // Load persisted state
+         * await partial.waitForInit("BTCUSDT", "my-strategy", false); // Load persisted state (live mode)
          * // Now profit()/loss() can be called
          * ```
          */
-        this.waitForInit = functoolsKit.singleshot(async (symbol) => await WAIT_FOR_INIT_FN(symbol, this));
-        this._states = new Map();
+        this.waitForInit = functoolsKit.singleshot(async (symbol, strategyName) => await WAIT_FOR_INIT_FN(symbol, strategyName, this));
     }
     /**
      * Persists current partial state to disk.
@@ -11872,13 +11921,15 @@ class ClientPartial {
      * Uses atomic file writes via PersistPartialAdapter.
      *
      * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param backtest - True if backtest mode
      * @returns Promise that resolves when persistence is complete
      */
-    async _persistState(symbol, backtest) {
-        if (backtest) {
+    async _persistState(symbol, strategyName) {
+        if (this.params.backtest) {
             return;
         }
-        this.params.logger.debug("ClientPartial persistState", { symbol });
+        this.params.logger.debug("ClientPartial persistState", { symbol, strategyName });
         if (this._states === NEED_FETCH) {
             throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
         }
@@ -11889,7 +11940,7 @@ class ClientPartial {
                 lossLevels: Array.from(state.lossLevels),
             };
         }
-        await PersistPartialAdapter.writePartialData(partialData, symbol);
+        await PersistPartialAdapter.writePartialData(partialData, symbol, strategyName);
     }
     /**
      * Processes profit state and emits events for newly reached profit levels.
@@ -12010,8 +12061,11 @@ class ClientPartial {
         if (this._states === NEED_FETCH) {
             throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
         }
+        if (data.id !== this.params.signalId) {
+            throw new Error(`Signal ID mismatch: expected ${this.params.signalId}, got ${data.id}`);
+        }
         this._states.delete(data.id);
-        await this._persistState(symbol, backtest);
+        await this._persistState(symbol, data.strategyName);
     }
 }
 
@@ -12106,15 +12160,17 @@ class PartialConnectionService {
         /**
          * Memoized factory function for ClientPartial instances.
          *
-         * Creates one ClientPartial per signal ID with configured callbacks.
+         * Creates one ClientPartial per signal ID and backtest mode with configured callbacks.
          * Instances are cached until clear() is called.
          *
-         * Key format: signalId
+         * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientPartial instance with logger and event emitters
          */
-        this.getPartial = functoolsKit.memoize(([signalId]) => `${signalId}`, () => {
+        this.getPartial = functoolsKit.memoize(([signalId, backtest]) => `${signalId}:${backtest ? "backtest" : "live"}`, (signalId, backtest) => {
             return new ClientPartial({
+                signalId,
                 logger: this.loggerService,
+                backtest,
                 onProfit: COMMIT_PROFIT_FN,
                 onLoss: COMMIT_LOSS_FN,
             });
@@ -12142,8 +12198,8 @@ class PartialConnectionService {
                 backtest,
                 when,
             });
-            const partial = this.getPartial(data.id);
-            await partial.waitForInit(symbol);
+            const partial = this.getPartial(data.id, backtest);
+            await partial.waitForInit(symbol, data.strategyName);
             return await partial.profit(symbol, data, currentPrice, revenuePercent, backtest, when);
         };
         /**
@@ -12169,8 +12225,8 @@ class PartialConnectionService {
                 backtest,
                 when,
             });
-            const partial = this.getPartial(data.id);
-            await partial.waitForInit(symbol);
+            const partial = this.getPartial(data.id, backtest);
+            await partial.waitForInit(symbol, data.strategyName);
             return await partial.loss(symbol, data, currentPrice, lossPercent, backtest, when);
         };
         /**
@@ -12191,15 +12247,17 @@ class PartialConnectionService {
          * @returns Promise that resolves when clear is complete
          */
         this.clear = async (symbol, data, priceClose, backtest) => {
-            this.loggerService.log("partialConnectionService profit", {
+            this.loggerService.log("partialConnectionService clear", {
                 symbol,
                 data,
                 priceClose,
+                backtest,
             });
-            const partial = this.getPartial(data.id);
-            await partial.waitForInit(symbol);
+            const partial = this.getPartial(data.id, backtest);
+            await partial.waitForInit(symbol, data.strategyName);
             await partial.clear(symbol, data, priceClose, backtest);
-            this.getPartial.clear(data.id);
+            const key = `${data.id}:${backtest ? "backtest" : "live"}`;
+            this.getPartial.clear(key);
         };
     }
 }
@@ -15551,12 +15609,12 @@ class BacktestInstance {
                 backtest$1.scheduleMarkdownService.clear({ symbol, strategyName: context.strategyName });
             }
             {
-                backtest$1.strategyCoreService.clear({ symbol, strategyName: context.strategyName });
+                backtest$1.strategyCoreService.clear(true, { symbol, strategyName: context.strategyName });
             }
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
-                riskName && backtest$1.riskGlobalService.clear(riskName);
-                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(riskName));
+                riskName && backtest$1.riskGlobalService.clear(true, riskName);
+                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(true, riskName));
             }
             return backtest$1.backtestCommandService.run(symbol, context);
         };
@@ -15587,9 +15645,9 @@ class BacktestInstance {
             });
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                backtest$1.strategyCoreService.stop({ symbol, strategyName: context.strategyName }, true);
+                backtest$1.strategyCoreService.stop(true, { symbol, strategyName: context.strategyName });
                 backtest$1.strategyCoreService
-                    .getPendingSignal(symbol, context.strategyName)
+                    .getPendingSignal(true, symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
                         return;
@@ -15629,7 +15687,7 @@ class BacktestInstance {
                 symbol,
                 strategyName,
             });
-            await backtest$1.strategyCoreService.stop({ symbol, strategyName }, true);
+            await backtest$1.strategyCoreService.stop(true, { symbol, strategyName });
         };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
@@ -16055,12 +16113,12 @@ class LiveInstance {
                 backtest$1.scheduleMarkdownService.clear({ symbol, strategyName: context.strategyName });
             }
             {
-                backtest$1.strategyCoreService.clear({ symbol, strategyName: context.strategyName });
+                backtest$1.strategyCoreService.clear(false, { symbol, strategyName: context.strategyName });
             }
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
-                riskName && backtest$1.riskGlobalService.clear(riskName);
-                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(riskName));
+                riskName && backtest$1.riskGlobalService.clear(false, riskName);
+                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(false, riskName));
             }
             return backtest$1.liveCommandService.run(symbol, context);
         };
@@ -16091,9 +16149,9 @@ class LiveInstance {
             });
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                backtest$1.strategyCoreService.stop({ symbol, strategyName: context.strategyName }, false);
+                backtest$1.strategyCoreService.stop(false, { symbol, strategyName: context.strategyName });
                 backtest$1.strategyCoreService
-                    .getPendingSignal(symbol, context.strategyName)
+                    .getPendingSignal(false, symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
                         return;
@@ -16133,7 +16191,7 @@ class LiveInstance {
                 symbol,
                 strategyName,
             });
-            await backtest$1.strategyCoreService.stop({ symbol, strategyName }, false);
+            await backtest$1.strategyCoreService.stop(false, { symbol, strategyName });
         };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
@@ -16837,12 +16895,13 @@ class WalkerInstance {
                     backtest$1.scheduleMarkdownService.clear({ symbol, strategyName });
                 }
                 {
-                    backtest$1.strategyCoreService.clear({ symbol, strategyName });
+                    backtest$1.strategyCoreService.clear(true, { symbol, strategyName });
                 }
                 {
                     const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                    riskName && backtest$1.riskGlobalService.clear(riskName);
-                    riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(riskName));
+                    riskName && backtest$1.riskGlobalService.clear(true, riskName);
+                    riskList &&
+                        riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(true, riskName));
                 }
             }
             return backtest$1.walkerCommandService.run(symbol, {
@@ -16878,8 +16937,12 @@ class WalkerInstance {
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
-                    backtest$1.strategyCoreService.stop({ symbol, strategyName }, true);
-                    walkerStopSubject.next({ symbol, strategyName, walkerName: context.walkerName });
+                    backtest$1.strategyCoreService.stop(true, { symbol, strategyName });
+                    walkerStopSubject.next({
+                        symbol,
+                        strategyName,
+                        walkerName: context.walkerName,
+                    });
                 }
                 if (!this._isDone) {
                     doneWalkerSubject.next({
@@ -16924,7 +16987,7 @@ class WalkerInstance {
             const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
                 await walkerStopSubject.next({ symbol, strategyName, walkerName });
-                await backtest$1.strategyCoreService.stop({ symbol, strategyName }, true);
+                await backtest$1.strategyCoreService.stop(true, { symbol, strategyName });
             }
         };
         /**
@@ -17053,8 +17116,10 @@ class WalkerUtils {
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_RUN);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN));
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN));
             }
             const instance = this._getInstance(symbol, context.walkerName);
             return instance.run(symbol, context);
@@ -17086,8 +17151,10 @@ class WalkerUtils {
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_BACKGROUND);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND));
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND));
             }
             const instance = this._getInstance(symbol, context.walkerName);
             return instance.background(symbol, context);
@@ -17121,8 +17188,10 @@ class WalkerUtils {
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_STOP);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP));
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.stop(symbol, walkerName);
@@ -17146,8 +17215,10 @@ class WalkerUtils {
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_DATA);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA));
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.getData(symbol, walkerName);
@@ -17173,8 +17244,10 @@ class WalkerUtils {
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_REPORT);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT));
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.getReport(symbol, walkerName, strategyColumns, pnlColumns);
@@ -17203,8 +17276,10 @@ class WalkerUtils {
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_DUMP);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP));
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.dump(symbol, walkerName, path, strategyColumns, pnlColumns);