backtest-kit 9.8.5 → 10.2.0

package/build/index.cjs

@@ -962,7 +962,7 @@ async function writeFileAtomic(file, data, options = {}) {
 
 var _a$3;
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$8 = new LoggerService();
+const LOGGER_SERVICE$9 = new LoggerService();
 /** Symbol key for the singleshot waitForInit function on PersistBase instances. */
 const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
 // Calculate step in milliseconds for candle close time validation
@@ -1085,7 +1085,7 @@ const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
 const BASE_UNLINK_RETRY_COUNT = 5;
 const BASE_UNLINK_RETRY_DELAY = 1000;
 const BASE_WAIT_FOR_INIT_FN = async (self) => {
-    LOGGER_SERVICE$8.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
+    LOGGER_SERVICE$9.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
         entityName: self.entityName,
         directory: self._directory,
     });
@@ -1143,7 +1143,7 @@ class PersistBase {
         this.entityName = entityName;
         this.baseDir = baseDir;
         this[_a$3] = functoolsKit.singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
-        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
+        LOGGER_SERVICE$9.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
             entityName: this.entityName,
             baseDir,
         });
@@ -1159,14 +1159,14 @@ class PersistBase {
         return path.join(this.baseDir, this.entityName, `${entityId}.json`);
     }
     async waitForInit(initial) {
-        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
+        LOGGER_SERVICE$9.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
             entityName: this.entityName,
             initial,
         });
         await this[BASE_WAIT_FOR_INIT_SYMBOL]();
     }
     async readValue(entityId) {
-        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
+        LOGGER_SERVICE$9.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -1183,7 +1183,7 @@ class PersistBase {
         }
     }
     async hasValue(entityId) {
-        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
+        LOGGER_SERVICE$9.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -1200,7 +1200,7 @@ class PersistBase {
         }
     }
     async writeValue(entityId, entity) {
-        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
+        LOGGER_SERVICE$9.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -1222,7 +1222,7 @@ class PersistBase {
      * @throws Error if reading fails
      */
     async *keys() {
-        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
+        LOGGER_SERVICE$9.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
             entityName: this.entityName,
         });
         try {
@@ -1367,7 +1367,7 @@ class PersistSignalUtils {
          * @returns Promise resolving to signal or null if none persisted
          */
         this.readSignalData = async (symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$8.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(symbol, strategyName, exchangeName);
@@ -1385,7 +1385,7 @@ class PersistSignalUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeSignalData = async (signalRow, symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$8.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(symbol, strategyName, exchangeName);
@@ -1400,7 +1400,7 @@ class PersistSignalUtils {
      * @param Ctor - Custom IPersistSignalInstance constructor
      */
     usePersistSignalAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
         this.PersistSignalInstanceCtor = Ctor;
         this.getStorage.clear();
     }
@@ -1409,21 +1409,21 @@ class PersistSignalUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
      * Switches to the default file-based PersistSignalInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistSignalAdapter(PersistSignalInstance);
     }
     /**
      * Switches to PersistSignalDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistSignalAdapter(PersistSignalDummyInstance);
     }
 }
@@ -1563,7 +1563,7 @@ class PersistRiskUtils {
          * @returns Promise resolving to position entries (empty array if none)
          */
         this.readPositionData = async (riskName, exchangeName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
             const key = `${riskName}:${exchangeName}`;
             const isInitial = !this.getRiskStorage.has(key);
             const instance = this.getRiskStorage(riskName, exchangeName);
@@ -1581,7 +1581,7 @@ class PersistRiskUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writePositionData = async (riskRow, riskName, exchangeName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${riskName}:${exchangeName}`;
             const isInitial = !this.getRiskStorage.has(key);
             const instance = this.getRiskStorage(riskName, exchangeName);
@@ -1596,7 +1596,7 @@ class PersistRiskUtils {
      * @param Ctor - Custom IPersistRiskInstance constructor
      */
     usePersistRiskAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
         this.PersistRiskInstanceCtor = Ctor;
         this.getRiskStorage.clear();
     }
@@ -1605,21 +1605,21 @@ class PersistRiskUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_RISK_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_RISK_UTILS_METHOD_NAME_CLEAR);
         this.getRiskStorage.clear();
     }
     /**
      * Switches to the default file-based PersistRiskInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistRiskAdapter(PersistRiskInstance);
     }
     /**
      * Switches to PersistRiskDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistRiskAdapter(PersistRiskDummyInstance);
     }
 }
@@ -1758,7 +1758,7 @@ class PersistScheduleUtils {
          * @returns Promise resolving to scheduled signal or null if none persisted
          */
         this.readScheduleData = async (symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$8.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getScheduleStorage.has(key);
             const instance = this.getScheduleStorage(symbol, strategyName, exchangeName);
@@ -1776,7 +1776,7 @@ class PersistScheduleUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeScheduleData = async (scheduledSignalRow, symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$8.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getScheduleStorage.has(key);
             const instance = this.getScheduleStorage(symbol, strategyName, exchangeName);
@@ -1791,7 +1791,7 @@ class PersistScheduleUtils {
      * @param Ctor - Custom IPersistScheduleInstance constructor
      */
     usePersistScheduleAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
         this.PersistScheduleInstanceCtor = Ctor;
         this.getScheduleStorage.clear();
     }
@@ -1800,21 +1800,21 @@ class PersistScheduleUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_CLEAR);
         this.getScheduleStorage.clear();
     }
     /**
      * Switches to the default file-based PersistScheduleInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistScheduleAdapter(PersistScheduleInstance);
     }
     /**
      * Switches to PersistScheduleDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistScheduleAdapter(PersistScheduleDummyInstance);
     }
 }
@@ -1959,7 +1959,7 @@ class PersistPartialUtils {
          * @returns Promise resolving to partial data record (empty object if none)
          */
         this.readPartialData = async (symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getPartialStorage.has(key);
             const instance = this.getPartialStorage(symbol, strategyName, exchangeName);
@@ -1979,7 +1979,7 @@ class PersistPartialUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writePartialData = async (partialData, symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getPartialStorage.has(key);
             const instance = this.getPartialStorage(symbol, strategyName, exchangeName);
@@ -1994,7 +1994,7 @@ class PersistPartialUtils {
      * @param Ctor - Custom IPersistPartialInstance constructor
      */
     usePersistPartialAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
         this.PersistPartialInstanceCtor = Ctor;
         this.getPartialStorage.clear();
     }
@@ -2003,21 +2003,21 @@ class PersistPartialUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_CLEAR);
         this.getPartialStorage.clear();
     }
     /**
      * Switches to the default file-based PersistPartialInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistPartialAdapter(PersistPartialInstance);
     }
     /**
      * Switches to PersistPartialDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistPartialAdapter(PersistPartialDummyInstance);
     }
 }
@@ -2182,7 +2182,7 @@ class PersistBreakevenUtils {
          * @returns Promise resolving to breakeven data record (empty object if none)
          */
         this.readBreakevenData = async (symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getBreakevenStorage.has(key);
             const instance = this.getBreakevenStorage(symbol, strategyName, exchangeName);
@@ -2202,7 +2202,7 @@ class PersistBreakevenUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeBreakevenData = async (breakevenData, symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getBreakevenStorage.has(key);
             const instance = this.getBreakevenStorage(symbol, strategyName, exchangeName);
@@ -2217,7 +2217,7 @@ class PersistBreakevenUtils {
      * @param Ctor - Custom IPersistBreakevenInstance constructor
      */
     usePersistBreakevenAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
         this.PersistBreakevenInstanceCtor = Ctor;
         this.getBreakevenStorage.clear();
     }
@@ -2226,21 +2226,21 @@ class PersistBreakevenUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_CLEAR);
         this.getBreakevenStorage.clear();
     }
     /**
      * Switches to the default file-based PersistBreakevenInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistBreakevenAdapter(PersistBreakevenInstance);
     }
     /**
      * Switches to PersistBreakevenDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistBreakevenAdapter(PersistBreakevenDummyInstance);
     }
 }
@@ -2331,7 +2331,7 @@ class PersistCandleInstance {
                     error: functoolsKit.errorData(error),
                     message: functoolsKit.getErrorMessage(error),
                 };
-                LOGGER_SERVICE$8.warn(message, payload);
+                LOGGER_SERVICE$9.warn(message, payload);
                 console.warn(message, payload);
                 errorEmitter.next(error);
                 return null;
@@ -2353,7 +2353,7 @@ class PersistCandleInstance {
         for (const candle of candles) {
             const candleCloseTime = candle.timestamp + stepMs;
             if (candleCloseTime > now) {
-                LOGGER_SERVICE$8.debug("PersistCandleInstance.writeCandlesData: skipping incomplete candle", {
+                LOGGER_SERVICE$9.debug("PersistCandleInstance.writeCandlesData: skipping incomplete candle", {
                     symbol: this.symbol,
                     interval: this.interval,
                     exchangeName: this.exchangeName,
@@ -2430,7 +2430,7 @@ class PersistCandleUtils {
          * @returns Promise resolving to candles in order, or null on cache miss
          */
         this.readCandlesData = async (symbol, interval, exchangeName, limit, sinceTimestamp, untilTimestamp) => {
-            LOGGER_SERVICE$8.info("PersistCandleUtils.readCandlesData", {
+            LOGGER_SERVICE$9.info("PersistCandleUtils.readCandlesData", {
                 symbol,
                 interval,
                 exchangeName,
@@ -2454,7 +2454,7 @@ class PersistCandleUtils {
          * @returns Promise that resolves when all writes are complete
          */
         this.writeCandlesData = async (candles, symbol, interval, exchangeName) => {
-            LOGGER_SERVICE$8.info("PersistCandleUtils.writeCandlesData", {
+            LOGGER_SERVICE$9.info("PersistCandleUtils.writeCandlesData", {
                 symbol,
                 interval,
                 exchangeName,
@@ -2474,7 +2474,7 @@ class PersistCandleUtils {
      * @param Ctor - Custom IPersistCandleInstance constructor
      */
     usePersistCandleAdapter(Ctor) {
-        LOGGER_SERVICE$8.info("PersistCandleUtils.usePersistCandleAdapter");
+        LOGGER_SERVICE$9.info("PersistCandleUtils.usePersistCandleAdapter");
         this.PersistCandleInstanceCtor = Ctor;
         this.getCandlesStorage.clear();
     }
@@ -2483,21 +2483,21 @@ class PersistCandleUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_CANDLE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_CANDLE_UTILS_METHOD_NAME_CLEAR);
         this.getCandlesStorage.clear();
     }
     /**
      * Switches to the default file-based PersistCandleInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log("PersistCandleUtils.useJson");
+        LOGGER_SERVICE$9.log("PersistCandleUtils.useJson");
         this.usePersistCandleAdapter(PersistCandleInstance);
     }
     /**
      * Switches to PersistCandleDummyInstance (always returns null on read, discards writes).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log("PersistCandleUtils.useDummy");
+        LOGGER_SERVICE$9.log("PersistCandleUtils.useDummy");
         this.usePersistCandleAdapter(PersistCandleDummyInstance);
     }
 }
@@ -2635,7 +2635,7 @@ class PersistStorageUtils {
          * @returns Promise resolving to array of signal entries
          */
         this.readStorageData = async (backtest) => {
-            LOGGER_SERVICE$8.info(PERSIST_STORAGE_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_STORAGE_UTILS_METHOD_NAME_READ_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(backtest);
@@ -2651,7 +2651,7 @@ class PersistStorageUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeStorageData = async (signalData, backtest) => {
-            LOGGER_SERVICE$8.info(PERSIST_STORAGE_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_STORAGE_UTILS_METHOD_NAME_WRITE_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(backtest);
@@ -2666,7 +2666,7 @@ class PersistStorageUtils {
      * @param Ctor - Custom IPersistStorageInstance constructor
      */
     usePersistStorageAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_PERSIST_STORAGE_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_PERSIST_STORAGE_ADAPTER);
         this.PersistStorageInstanceCtor = Ctor;
         this.getStorage.clear();
     }
@@ -2675,21 +2675,21 @@ class PersistStorageUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_STORAGE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_STORAGE_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
      * Switches to the default file-based PersistStorageInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistStorageAdapter(PersistStorageInstance);
     }
     /**
      * Switches to PersistStorageDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistStorageAdapter(PersistStorageDummyInstance);
     }
 }
@@ -2816,7 +2816,7 @@ class PersistNotificationUtils {
          * @returns Promise resolving to array of notification entries
          */
         this.readNotificationData = async (backtest) => {
-            LOGGER_SERVICE$8.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_READ_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getNotificationStorage.has(key);
             const instance = this.getNotificationStorage(backtest);
@@ -2832,7 +2832,7 @@ class PersistNotificationUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeNotificationData = async (notificationData, backtest) => {
-            LOGGER_SERVICE$8.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_WRITE_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getNotificationStorage.has(key);
             const instance = this.getNotificationStorage(backtest);
@@ -2847,7 +2847,7 @@ class PersistNotificationUtils {
      * @param Ctor - Custom IPersistNotificationInstance constructor
      */
     usePersistNotificationAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_PERSIST_NOTIFICATION_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_PERSIST_NOTIFICATION_ADAPTER);
         this.PersistNotificationInstanceCtor = Ctor;
         this.getNotificationStorage.clear();
     }
@@ -2857,21 +2857,21 @@ class PersistNotificationUtils {
      * instances are created with the updated base path.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_CLEAR);
         this.getNotificationStorage.clear();
     }
     /**
      * Switches to the default file-based PersistNotificationInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistNotificationAdapter(PersistNotificationInstance);
     }
     /**
      * Switches to PersistNotificationDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistNotificationAdapter(PersistNotificationDummyInstance);
     }
 }
@@ -2995,7 +2995,7 @@ class PersistLogUtils {
          * @returns Promise resolving to array of log entries
          */
         this.readLogData = async () => {
-            LOGGER_SERVICE$8.info(PERSIST_LOG_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_LOG_UTILS_METHOD_NAME_READ_DATA);
             const isInitial = !this._logInstance;
             const instance = this.getLogInstance();
             await instance.waitForInit(isInitial);
@@ -3009,7 +3009,7 @@ class PersistLogUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeLogData = async (logData) => {
-            LOGGER_SERVICE$8.info(PERSIST_LOG_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_LOG_UTILS_METHOD_NAME_WRITE_DATA);
             const isInitial = !this._logInstance;
             const instance = this.getLogInstance();
             await instance.waitForInit(isInitial);
@@ -3034,7 +3034,7 @@ class PersistLogUtils {
      * @param Ctor - Custom IPersistLogInstance constructor
      */
     usePersistLogAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_LOG_UTILS_METHOD_NAME_USE_PERSIST_LOG_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_LOG_UTILS_METHOD_NAME_USE_PERSIST_LOG_ADAPTER);
         this.PersistLogInstanceCtor = Ctor;
         this._logInstance = null;
     }
@@ -3043,21 +3043,21 @@ class PersistLogUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_LOG_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_LOG_UTILS_METHOD_NAME_CLEAR);
         this._logInstance = null;
     }
     /**
      * Switches to the default file-based PersistLogInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistLogAdapter(PersistLogInstance);
     }
     /**
      * Switches to PersistLogDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistLogAdapter(PersistLogDummyInstance);
     }
 }
@@ -3219,7 +3219,7 @@ class PersistMeasureUtils {
          * @returns Promise resolving to cached value, or null if not found / soft-deleted
          */
         this.readMeasureData = async (bucket, key) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEASURE_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
+            LOGGER_SERVICE$9.info(PERSIST_MEASURE_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
             const isInitial = !this.getMeasureStorage.has(bucket);
             const instance = this.getMeasureStorage(bucket);
             await instance.waitForInit(isInitial);
@@ -3235,7 +3235,7 @@ class PersistMeasureUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeMeasureData = async (data, bucket, key, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEASURE_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
+            LOGGER_SERVICE$9.info(PERSIST_MEASURE_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
             const isInitial = !this.getMeasureStorage.has(bucket);
             const instance = this.getMeasureStorage(bucket);
             await instance.waitForInit(isInitial);
@@ -3250,7 +3250,7 @@ class PersistMeasureUtils {
          * @returns Promise that resolves when removal is complete
          */
         this.removeMeasureData = async (bucket, key) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEASURE_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
+            LOGGER_SERVICE$9.info(PERSIST_MEASURE_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
             const isInitial = !this.getMeasureStorage.has(bucket);
             const instance = this.getMeasureStorage(bucket);
             await instance.waitForInit(isInitial);
@@ -3264,7 +3264,7 @@ class PersistMeasureUtils {
      * @param Ctor - Custom IPersistMeasureInstance constructor
      */
     usePersistMeasureAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_PERSIST_MEASURE_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_PERSIST_MEASURE_ADAPTER);
         this.PersistMeasureInstanceCtor = Ctor;
         this.getMeasureStorage.clear();
     }
@@ -3276,7 +3276,7 @@ class PersistMeasureUtils {
      * @returns AsyncGenerator yielding entry keys
      */
     async *listMeasureData(bucket) {
-        LOGGER_SERVICE$8.info(PERSIST_MEASURE_UTILS_METHOD_NAME_LIST_DATA, { bucket });
+        LOGGER_SERVICE$9.info(PERSIST_MEASURE_UTILS_METHOD_NAME_LIST_DATA, { bucket });
         const isInitial = !this.getMeasureStorage.has(bucket);
         const instance = this.getMeasureStorage(bucket);
         await instance.waitForInit(isInitial);
@@ -3287,21 +3287,21 @@ class PersistMeasureUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_MEASURE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_MEASURE_UTILS_METHOD_NAME_CLEAR);
         this.getMeasureStorage.clear();
     }
     /**
      * Switches to the default file-based PersistMeasureInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistMeasureAdapter(PersistMeasureInstance);
     }
     /**
      * Switches to PersistMeasureDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistMeasureAdapter(PersistMeasureDummyInstance);
     }
 }
@@ -3460,7 +3460,7 @@ class PersistIntervalUtils {
          * @returns Promise resolving to marker data, or null if not found / soft-deleted
          */
         this.readIntervalData = async (bucket, key) => {
-            LOGGER_SERVICE$8.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
+            LOGGER_SERVICE$9.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
             const isInitial = !this.getIntervalStorage.has(bucket);
             const instance = this.getIntervalStorage(bucket);
             await instance.waitForInit(isInitial);
@@ -3476,7 +3476,7 @@ class PersistIntervalUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeIntervalData = async (data, bucket, key, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
+            LOGGER_SERVICE$9.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
             const isInitial = !this.getIntervalStorage.has(bucket);
             const instance = this.getIntervalStorage(bucket);
             await instance.waitForInit(isInitial);
@@ -3491,7 +3491,7 @@ class PersistIntervalUtils {
          * @returns Promise that resolves when removal is complete
          */
         this.removeIntervalData = async (bucket, key) => {
-            LOGGER_SERVICE$8.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
+            LOGGER_SERVICE$9.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
             const isInitial = !this.getIntervalStorage.has(bucket);
             const instance = this.getIntervalStorage(bucket);
             await instance.waitForInit(isInitial);
@@ -3505,7 +3505,7 @@ class PersistIntervalUtils {
      * @param Ctor - Custom IPersistIntervalInstance constructor
      */
     usePersistIntervalAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_PERSIST_INTERVAL_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_PERSIST_INTERVAL_ADAPTER);
         this.PersistIntervalInstanceCtor = Ctor;
         this.getIntervalStorage.clear();
     }
@@ -3517,7 +3517,7 @@ class PersistIntervalUtils {
      * @returns AsyncGenerator yielding marker keys
      */
     async *listIntervalData(bucket) {
-        LOGGER_SERVICE$8.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_LIST_DATA, { bucket });
+        LOGGER_SERVICE$9.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_LIST_DATA, { bucket });
         const isInitial = !this.getIntervalStorage.has(bucket);
         const instance = this.getIntervalStorage(bucket);
         await instance.waitForInit(isInitial);
@@ -3528,21 +3528,21 @@ class PersistIntervalUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_CLEAR);
         this.getIntervalStorage.clear();
     }
     /**
      * Switches to the default file-based PersistIntervalInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistIntervalAdapter(PersistIntervalInstance);
     }
     /**
      * Switches to PersistIntervalDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistIntervalAdapter(PersistIntervalDummyInstance);
     }
 }
@@ -3748,7 +3748,7 @@ class PersistMemoryUtils {
          * @returns Promise resolving to entry data, or null if not found / soft-deleted
          */
         this.readMemoryData = async (signalId, bucketName, memoryId) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
             const instance = this.getMemoryStorage(signalId, bucketName);
@@ -3765,7 +3765,7 @@ class PersistMemoryUtils {
          * @returns Promise resolving to true if entry exists
          */
         this.hasMemoryData = async (signalId, bucketName, memoryId) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_HAS_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_HAS_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
             const instance = this.getMemoryStorage(signalId, bucketName);
@@ -3784,7 +3784,7 @@ class PersistMemoryUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeMemoryData = async (data, signalId, bucketName, memoryId, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
             const instance = this.getMemoryStorage(signalId, bucketName);
@@ -3801,7 +3801,7 @@ class PersistMemoryUtils {
          * @returns Promise that resolves when removal is complete
          */
         this.removeMemoryData = async (signalId, bucketName, memoryId) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_REMOVE_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_REMOVE_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
             const instance = this.getMemoryStorage(signalId, bucketName);
@@ -3813,7 +3813,7 @@ class PersistMemoryUtils {
          * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
-            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_CLEAR);
+            LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_CLEAR);
             this.getMemoryStorage.clear();
         };
         /**
@@ -3824,7 +3824,7 @@ class PersistMemoryUtils {
          * @param bucketName - Bucket name
          */
         this.dispose = (signalId, bucketName) => {
-            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_DISPOSE);
+            LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_DISPOSE);
             const key = `${signalId}:${bucketName}`;
             this.getMemoryStorage.clear(key);
         };
@@ -3836,7 +3836,7 @@ class PersistMemoryUtils {
      * @param Ctor - Custom IPersistMemoryInstance constructor
      */
     usePersistMemoryAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_USE_PERSIST_MEMORY_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_USE_PERSIST_MEMORY_ADAPTER);
         this.PersistMemoryInstanceCtor = Ctor;
         this.getMemoryStorage.clear();
     }
@@ -3850,7 +3850,7 @@ class PersistMemoryUtils {
      * @returns AsyncGenerator yielding `{ memoryId, data }` tuples
      */
     async *listMemoryData(signalId, bucketName) {
-        LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_LIST_DATA, { signalId, bucketName });
+        LOGGER_SERVICE$9.info(PERSIST_MEMORY_UTILS_METHOD_NAME_LIST_DATA, { signalId, bucketName });
         const key = `${signalId}:${bucketName}`;
         const isInitial = !this.getMemoryStorage.has(key);
         const instance = this.getMemoryStorage(signalId, bucketName);
@@ -3861,14 +3861,14 @@ class PersistMemoryUtils {
      * Switches to the default file-based PersistMemoryInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistMemoryAdapter(PersistMemoryInstance);
     }
     /**
      * Switches to PersistMemoryDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistMemoryAdapter(PersistMemoryDummyInstance);
     }
 }
@@ -4017,7 +4017,7 @@ class PersistRecentUtils {
          * @returns Promise resolving to recent signal or null if none persisted
          */
         this.readRecentData = async (symbol, strategyName, exchangeName, frameName, backtest) => {
-            LOGGER_SERVICE$8.info(PERSIST_RECENT_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_RECENT_UTILS_METHOD_NAME_READ_DATA);
             const key = this.createKey(symbol, strategyName, exchangeName, frameName, backtest);
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
@@ -4038,7 +4038,7 @@ class PersistRecentUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeRecentData = async (signalRow, symbol, strategyName, exchangeName, frameName, backtest, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_RECENT_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$9.info(PERSIST_RECENT_UTILS_METHOD_NAME_WRITE_DATA);
             const key = this.createKey(symbol, strategyName, exchangeName, frameName, backtest);
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
@@ -4071,7 +4071,7 @@ class PersistRecentUtils {
      * @param Ctor - Custom IPersistRecentInstance constructor
      */
     usePersistRecentAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_RECENT_UTILS_METHOD_NAME_USE_PERSIST_RECENT_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_RECENT_UTILS_METHOD_NAME_USE_PERSIST_RECENT_ADAPTER);
         this.PersistRecentInstanceCtor = Ctor;
         this.getStorage.clear();
     }
@@ -4080,21 +4080,21 @@ class PersistRecentUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$8.log(PERSIST_RECENT_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$9.log(PERSIST_RECENT_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
      * Switches to the default file-based PersistRecentInstance.
      */
     useJson() {
-        LOGGER_SERVICE$8.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$9.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistRecentAdapter(PersistRecentInstance);
     }
     /**
      * Switches to PersistRecentDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$8.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$9.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistRecentAdapter(PersistRecentDummyInstance);
     }
 }
@@ -4229,7 +4229,7 @@ class PersistStateUtils {
          * @returns Promise that resolves when initialization is complete
          */
         this.waitForInit = async (signalId, bucketName, initial) => {
-            LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_WAIT_FOR_INIT, { signalId, bucketName, initial });
+            LOGGER_SERVICE$9.info(PERSIST_STATE_UTILS_METHOD_NAME_WAIT_FOR_INIT, { signalId, bucketName, initial });
             const key = `${signalId}:${bucketName}`;
             const isInitial = initial && !this.getStateStorage.has(key);
             const instance = this.getStateStorage(signalId, bucketName);
@@ -4244,7 +4244,7 @@ class PersistStateUtils {
          * @returns Promise resolving to state data or null if none persisted
          */
         this.readStateData = async (signalId, bucketName) => {
-            LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName });
+            LOGGER_SERVICE$9.info(PERSIST_STATE_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getStateStorage.has(key);
             const instance = this.getStateStorage(signalId, bucketName);
@@ -4262,7 +4262,7 @@ class PersistStateUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeStateData = async (data, signalId, bucketName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName });
+            LOGGER_SERVICE$9.info(PERSIST_STATE_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getStateStorage.has(key);
             const instance = this.getStateStorage(signalId, bucketName);
@@ -4273,14 +4273,14 @@ class PersistStateUtils {
          * Switches to PersistStateDummyInstance (all operations are no-ops).
          */
         this.useDummy = () => {
-            LOGGER_SERVICE$8.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_DUMMY);
+            LOGGER_SERVICE$9.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_DUMMY);
             this.usePersistStateAdapter(PersistStateDummyInstance);
         };
         /**
          * Switches to the default file-based PersistStateInstance.
          */
         this.useJson = () => {
-            LOGGER_SERVICE$8.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_JSON);
+            LOGGER_SERVICE$9.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_JSON);
             this.usePersistStateAdapter(PersistStateInstance);
         };
         /**
@@ -4288,7 +4288,7 @@ class PersistStateUtils {
          * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
-            LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_CLEAR);
+            LOGGER_SERVICE$9.info(PERSIST_STATE_UTILS_METHOD_NAME_CLEAR);
             this.getStateStorage.clear();
         };
         /**
@@ -4299,7 +4299,7 @@ class PersistStateUtils {
          * @param bucketName - Bucket name
          */
         this.dispose = (signalId, bucketName) => {
-            LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_DISPOSE);
+            LOGGER_SERVICE$9.info(PERSIST_STATE_UTILS_METHOD_NAME_DISPOSE);
             const key = `${signalId}:${bucketName}`;
             this.getStateStorage.clear(key);
         };
@@ -4311,7 +4311,7 @@ class PersistStateUtils {
      * @param Ctor - Custom IPersistStateInstance constructor
      */
     usePersistStateAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_USE_PERSIST_STATE_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_STATE_UTILS_METHOD_NAME_USE_PERSIST_STATE_ADAPTER);
         this.PersistStateInstanceCtor = Ctor;
         this.getStateStorage.clear();
     }
@@ -4451,7 +4451,7 @@ class PersistSessionUtils {
          * @returns Promise that resolves when initialization is complete
          */
         this.waitForInit = async (strategyName, exchangeName, frameName, initial) => {
-            LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_WAIT_FOR_INIT, { strategyName, exchangeName, frameName, initial });
+            LOGGER_SERVICE$9.info(PERSIST_SESSION_UTILS_METHOD_NAME_WAIT_FOR_INIT, { strategyName, exchangeName, frameName, initial });
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             const isInitial = initial && !this.getSessionStorage.has(key);
             const instance = this.getSessionStorage(strategyName, exchangeName, frameName);
@@ -4467,7 +4467,7 @@ class PersistSessionUtils {
          * @returns Promise resolving to session data or null if none persisted
          */
         this.readSessionData = async (strategyName, exchangeName, frameName) => {
-            LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_READ_DATA, { strategyName, exchangeName, frameName });
+            LOGGER_SERVICE$9.info(PERSIST_SESSION_UTILS_METHOD_NAME_READ_DATA, { strategyName, exchangeName, frameName });
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             const isInitial = !this.getSessionStorage.has(key);
             const instance = this.getSessionStorage(strategyName, exchangeName, frameName);
@@ -4486,7 +4486,7 @@ class PersistSessionUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeSessionData = async (data, strategyName, exchangeName, frameName, when) => {
-            LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_WRITE_DATA, { strategyName, exchangeName, frameName });
+            LOGGER_SERVICE$9.info(PERSIST_SESSION_UTILS_METHOD_NAME_WRITE_DATA, { strategyName, exchangeName, frameName });
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             const isInitial = !this.getSessionStorage.has(key);
             const instance = this.getSessionStorage(strategyName, exchangeName, frameName);
@@ -4497,14 +4497,14 @@ class PersistSessionUtils {
          * Switches to PersistSessionDummyInstance (all operations are no-ops).
          */
         this.useDummy = () => {
-            LOGGER_SERVICE$8.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_DUMMY);
+            LOGGER_SERVICE$9.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_DUMMY);
             this.usePersistSessionAdapter(PersistSessionDummyInstance);
         };
         /**
          * Switches to the default file-based PersistSessionInstance.
          */
         this.useJson = () => {
-            LOGGER_SERVICE$8.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_JSON);
+            LOGGER_SERVICE$9.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_JSON);
             this.usePersistSessionAdapter(PersistSessionInstance);
         };
         /**
@@ -4512,7 +4512,7 @@ class PersistSessionUtils {
          * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
-            LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_CLEAR);
+            LOGGER_SERVICE$9.info(PERSIST_SESSION_UTILS_METHOD_NAME_CLEAR);
             this.getSessionStorage.clear();
         };
         /**
@@ -4524,7 +4524,7 @@ class PersistSessionUtils {
          * @param frameName - Frame identifier
          */
         this.dispose = (strategyName, exchangeName, frameName) => {
-            LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_DISPOSE);
+            LOGGER_SERVICE$9.info(PERSIST_SESSION_UTILS_METHOD_NAME_DISPOSE);
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             this.getSessionStorage.clear(key);
         };
@@ -4536,7 +4536,7 @@ class PersistSessionUtils {
      * @param Ctor - Custom IPersistSessionInstance constructor
      */
     usePersistSessionAdapter(Ctor) {
-        LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_USE_PERSIST_SESSION_ADAPTER);
+        LOGGER_SERVICE$9.info(PERSIST_SESSION_UTILS_METHOD_NAME_USE_PERSIST_SESSION_ADAPTER);
         this.PersistSessionInstanceCtor = Ctor;
         this.getSessionStorage.clear();
     }
@@ -4658,7 +4658,7 @@ const METHOD_NAME_ADD_ACTIVITY = "LookupUtils.addActivity";
 const METHOD_NAME_REMOVE_ACTIVITY = "LookupUtils.removeActivity";
 const METHOD_NAME_LIST_ACTIVITY = "LookupUtils.listActivity";
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$7 = new LoggerService();
+const LOGGER_SERVICE$8 = new LoggerService();
 /**
  * Builds the composite {@link Key} used to register an activity in `_lookupMap`.
  *
@@ -4712,7 +4712,7 @@ class LookupUtils {
          * @param activity - Activity descriptor identifying the running workload.
          */
         this.addActivity = (activity) => {
-            LOGGER_SERVICE$7.info(METHOD_NAME_ADD_ACTIVITY, {
+            LOGGER_SERVICE$8.info(METHOD_NAME_ADD_ACTIVITY, {
                 activity,
             });
             const key = CREATE_KEY_FN$y(activity.symbol, activity.context.strategyName, activity.context.exchangeName, activity.context.frameName, activity.backtest);
@@ -4726,7 +4726,7 @@ class LookupUtils {
          * @param activity - Activity descriptor matching the one passed to {@link addActivity}.
          */
         this.removeActivity = (activity) => {
-            LOGGER_SERVICE$7.info(METHOD_NAME_REMOVE_ACTIVITY, {
+            LOGGER_SERVICE$8.info(METHOD_NAME_REMOVE_ACTIVITY, {
                 activity,
             });
             const key = CREATE_KEY_FN$y(activity.symbol, activity.context.strategyName, activity.context.exchangeName, activity.context.frameName, activity.backtest);
@@ -4738,7 +4738,7 @@ class LookupUtils {
          * @returns Array of all activities present in the lookup map at call time.
          */
         this.listActivity = () => {
-            LOGGER_SERVICE$7.info(METHOD_NAME_LIST_ACTIVITY);
+            LOGGER_SERVICE$8.info(METHOD_NAME_LIST_ACTIVITY);
             return Array.from(this._lookupMap.values());
         };
     }
@@ -4767,7 +4767,7 @@ const METHOD_NAME_SPIN_LOCK = "CandleUtils.spinLock";
  */
 const ROTATE_DELAY = 50;
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$6 = new LoggerService();
+const LOGGER_SERVICE$7 = new LoggerService();
 /**
  * Process-wide coordinator for candle-fetch serialization and cooperative
  * yielding between parallel backtests.
@@ -4816,7 +4816,7 @@ class CandleUtils {
          * @param source - Caller identifier for logging.
          */
         this.acquireLock = async (source) => {
-            LOGGER_SERVICE$6.info(METHOD_NAME_ACQUIRE_LOCK, {
+            LOGGER_SERVICE$7.info(METHOD_NAME_ACQUIRE_LOCK, {
                 source,
             });
             if (!GLOBAL_CONFIG.CC_ENABLE_CANDLE_FETCH_MUTEX) {
@@ -4832,7 +4832,7 @@ class CandleUtils {
          * @param source - Caller identifier for logging.
          */
         this.releaseLock = async (source) => {
-            LOGGER_SERVICE$6.info(METHOD_NAME_RELEASE_LOCK, {
+            LOGGER_SERVICE$7.info(METHOD_NAME_RELEASE_LOCK, {
                 source,
             });
             if (!GLOBAL_CONFIG.CC_ENABLE_CANDLE_FETCH_MUTEX) {
@@ -4857,7 +4857,7 @@ class CandleUtils {
          * @param source - Caller identifier for logging.
          */
         this.spinLock = async (source) => {
-            LOGGER_SERVICE$6.info(METHOD_NAME_SPIN_LOCK, {
+            LOGGER_SERVICE$7.info(METHOD_NAME_SPIN_LOCK, {
                 source,
             });
             if (!GLOBAL_CONFIG.CC_ENABLE_CANDLE_FETCH_MUTEX) {
@@ -6367,7 +6367,7 @@ const validateCommonSignal = (signal) => {
     }
     // Кидаем ошибку если есть проблемы
     if (errors.length > 0) {
-        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        throw new Error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
     }
 };
 
@@ -6420,7 +6420,7 @@ const validatePendingSignal = (signal, currentPrice) => {
         }
     }
     if (errors.length > 0) {
-        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        throw new Error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
     }
     validateCommonSignal(signal);
     // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ: проверяем что позиция не закроется сразу после открытия
@@ -6468,7 +6468,7 @@ const validatePendingSignal = (signal, currentPrice) => {
         }
     }
     if (errors.length > 0) {
-        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        throw new Error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
     }
 };
 
@@ -6521,7 +6521,7 @@ const validateScheduledSignal = (signal, currentPrice) => {
         }
     }
     if (errors.length > 0) {
-        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        throw new Error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
     }
     validateCommonSignal(signal);
     // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ scheduled сигналов
@@ -6567,7 +6567,7 @@ const validateScheduledSignal = (signal, currentPrice) => {
         // pendingAt === 0 is allowed for scheduled signals (set to SCHEDULED_SIGNAL_PENDING_MOCK until activation)
     }
     if (errors.length > 0) {
-        throw new Error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        throw new Error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
     }
 };
 
@@ -7014,6 +7014,13 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
     if (!signal) {
         return null;
     }
+    if (signal?.symbol && signal?.symbol !== self.params.execution.context.symbol) {
+        throw new Error(`Symbol mismatch: expected ${self.params.execution.context.symbol}, got ${signal.symbol}`);
+    }
+    // Whipsaw protection: skip signal if its id matches the last accepted pending id
+    if (signal.id && signal.id === self._lastPendingId) {
+        return null;
+    }
     if (self._isStopped) {
         return null;
     }
@@ -7057,6 +7064,9 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
             }
             // Валидируем сигнал перед возвратом
             validatePendingSignal(signalRow, currentPrice);
+            if (signal.id) {
+                self._lastPendingId = signal.id;
+            }
             return signalRow;
         }
         // ОЖИДАНИЕ АКТИВАЦИИ: создаем scheduled signal (risk check при активации)
@@ -7083,6 +7093,9 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
         };
         // Валидируем сигнал перед возвратом
         validateScheduledSignal(scheduledSignalRow, currentPrice);
+        if (signal.id) {
+            self._lastPendingId = signal.id;
+        }
         return scheduledSignalRow;
     }
     const signalRow = {
@@ -7110,6 +7123,9 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
     }
     // Валидируем сигнал перед возвратом
     validatePendingSignal(signalRow, currentPrice);
+    if (signal.id) {
+        self._lastPendingId = signal.id;
+    }
     return signalRow;
 }, {
     defaultValue: null,
@@ -7139,6 +7155,13 @@ const WAIT_FOR_INIT_FN$4 = async (self) => {
     if (self.params.execution.context.backtest) {
         return;
     }
+    // Restore last pending signal id for whipsaw protection in GET_SIGNAL_FN
+    {
+        const recentSignal = await PersistRecentAdapter.readRecentData(self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName, self.params.method.context.frameName, false);
+        if (recentSignal?.id) {
+            self._lastPendingId = recentSignal.id;
+        }
+    }
     // Restore pending signal
     const pendingSignal = await PersistSignalAdapter.readSignalData(self.params.execution.context.symbol, self.params.strategyName, self.params.exchangeName);
     if (pendingSignal) {
@@ -9279,6 +9302,7 @@ class ClientStrategy {
         this._isStopped = false;
         this._pendingSignal = null;
         this._lastSignalTimestamp = null;
+        this._lastPendingId = null;
         this._scheduledSignal = null;
         this._cancelledSignal = null;
         this._closedSignal = null;
@@ -12068,7 +12092,7 @@ const RISK_METHOD_NAME_CHECK_SIGNAL_AND_RESERVE = "MergeRisk.checkSignalAndReser
 const RISK_METHOD_NAME_ADD_SIGNAL = "MergeRisk.addSignal";
 const RISK_METHOD_NAME_REMOVE_SIGNAL = "MergeRisk.removeSignal";
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$5 = new LoggerService();
+const LOGGER_SERVICE$6 = new LoggerService();
 /**
  * Composite risk management class that combines multiple risk profiles.
  *
@@ -12124,7 +12148,7 @@ class MergeRisk {
      * @returns Promise resolving to true if all risks approve, false if any risk rejects
      */
     async checkSignal(params, options = {}) {
-        LOGGER_SERVICE$5.info(RISK_METHOD_NAME_CHECK_SIGNAL, {
+        LOGGER_SERVICE$6.info(RISK_METHOD_NAME_CHECK_SIGNAL, {
             params,
         });
         for (const [riskName, risk] of Object.entries(this._riskMap)) {
@@ -12154,7 +12178,7 @@ class MergeRisk {
      * @returns Promise resolving to true if all risks approve (and reserved), false if any risk rejects
      */
     async checkSignalAndReserve(params) {
-        LOGGER_SERVICE$5.info(RISK_METHOD_NAME_CHECK_SIGNAL_AND_RESERVE, {
+        LOGGER_SERVICE$6.info(RISK_METHOD_NAME_CHECK_SIGNAL_AND_RESERVE, {
             params,
         });
         for (const [riskName, risk] of Object.entries(this._riskMap)) {
@@ -12178,7 +12202,7 @@ class MergeRisk {
      * @returns Promise that resolves when all risks have registered the signal
      */
     async addSignal(symbol, context, positionData) {
-        LOGGER_SERVICE$5.info(RISK_METHOD_NAME_ADD_SIGNAL, {
+        LOGGER_SERVICE$6.info(RISK_METHOD_NAME_ADD_SIGNAL, {
             symbol,
             context,
         });
@@ -12195,7 +12219,7 @@ class MergeRisk {
      * @returns Promise that resolves when all risks have removed the signal
      */
     async removeSignal(symbol, context) {
-        LOGGER_SERVICE$5.info(RISK_METHOD_NAME_REMOVE_SIGNAL, {
+        LOGGER_SERVICE$6.info(RISK_METHOD_NAME_REMOVE_SIGNAL, {
             symbol,
             context,
         });
@@ -14988,7 +15012,7 @@ class RiskConnectionService {
 }
 
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$4 = new LoggerService();
+const LOGGER_SERVICE$5 = new LoggerService();
 /**
  * Wrapper to call init method with error capture.
  */
@@ -15003,7 +15027,7 @@ const CALL_INIT_FN = functoolsKit.trycatch(async (self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15023,7 +15047,7 @@ const CALL_SIGNAL_FN = functoolsKit.trycatch(async (event, self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15043,7 +15067,7 @@ const CALL_SIGNAL_LIVE_FN = functoolsKit.trycatch(async (event, self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15063,7 +15087,7 @@ const CALL_SIGNAL_BACKTEST_FN = functoolsKit.trycatch(async (event, self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15091,7 +15115,7 @@ const CALL_BREAKEVEN_AVAILABLE_FN = functoolsKit.trycatch(async (event, self) =>
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15119,7 +15143,7 @@ const CALL_PARTIAL_PROFIT_AVAILABLE_FN = functoolsKit.trycatch(async (event, sel
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15147,7 +15171,7 @@ const CALL_PARTIAL_LOSS_AVAILABLE_FN = functoolsKit.trycatch(async (event, self)
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15175,7 +15199,7 @@ const CALL_PING_SCHEDULED_FN = functoolsKit.trycatch(async (event, self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15203,7 +15227,7 @@ const CALL_PING_IDLE_FN = functoolsKit.trycatch(async (event, self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15231,7 +15255,7 @@ const CALL_PING_ACTIVE_FN = functoolsKit.trycatch(async (event, self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15251,7 +15275,7 @@ const CALL_RISK_REJECTION_FN = functoolsKit.trycatch(async (event, self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15271,7 +15295,7 @@ const CALL_DISPOSE_FN = functoolsKit.trycatch(async (self) => {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -23135,7 +23159,7 @@ const REPORT_UTILS_METHOD_NAME_USE_DUMMY$1 = "ReportUtils.useDummy";
 const REPORT_UTILS_METHOD_NAME_USE_JSONL$1 = "ReportUtils.useJsonl";
 const REPORT_UTILS_METHOD_NAME_CLEAR$1 = "ReportUtils.clear";
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$3 = new LoggerService();
+const LOGGER_SERVICE$4 = new LoggerService();
 /** Symbol key for the singleshot waitForInit function on MarkdownFileBase instances. */
 const WAIT_FOR_INIT_SYMBOL$1 = Symbol("wait-for-init");
 /** Symbol key for the timeout-protected write function on MarkdownFileBase instances. */
@@ -23216,7 +23240,7 @@ class MarkdownFileBase {
      * @throws Error if stream not initialized or write timeout exceeded
      */
     async dump(data, options) {
-        LOGGER_SERVICE$3.debug(MARKDOWN_METHOD_NAME_FILE_DUMP, {
+        LOGGER_SERVICE$4.debug(MARKDOWN_METHOD_NAME_FILE_DUMP, {
             markdownName: this.markdownName,
             options,
         });
@@ -23296,7 +23320,7 @@ class MarkdownFolderBase {
      * @throws Error if directory creation or file write fails
      */
     async dump(content, options) {
-        LOGGER_SERVICE$3.debug(MARKDOWN_METHOD_NAME_FOLDER_DUMP, {
+        LOGGER_SERVICE$4.debug(MARKDOWN_METHOD_NAME_FOLDER_DUMP, {
             markdownName: this.markdownName,
             options,
         });
@@ -23361,7 +23385,7 @@ class MarkdownWriterAdapter {
      * @param Ctor - Constructor for markdown storage adapter
      */
     useMarkdownAdapter(Ctor) {
-        LOGGER_SERVICE$3.info(MARKDOWN_METHOD_NAME_USE_ADAPTER$1);
+        LOGGER_SERVICE$4.info(MARKDOWN_METHOD_NAME_USE_ADAPTER$1);
         this.MarkdownFactory = Ctor;
     }
     /**
@@ -23375,7 +23399,7 @@ class MarkdownWriterAdapter {
      * @throws Error if write fails or storage initialization fails
      */
     async writeData(markdownName, content, options) {
-        LOGGER_SERVICE$3.debug(MARKDOWN_METHOD_NAME_WRITE_DATA, {
+        LOGGER_SERVICE$4.debug(MARKDOWN_METHOD_NAME_WRITE_DATA, {
             markdownName,
             options,
         });
@@ -23389,7 +23413,7 @@ class MarkdownWriterAdapter {
      * Each report is written as a separate .md file.
      */
     useMd() {
-        LOGGER_SERVICE$3.debug(MARKDOWN_METHOD_NAME_USE_MD$1);
+        LOGGER_SERVICE$4.debug(MARKDOWN_METHOD_NAME_USE_MD$1);
         this.useMarkdownAdapter(MarkdownFolderBase);
     }
     /**
@@ -23397,7 +23421,7 @@ class MarkdownWriterAdapter {
      * All reports are appended to a single .jsonl file per markdown type.
      */
     useJsonl() {
-        LOGGER_SERVICE$3.debug(MARKDOWN_METHOD_NAME_USE_JSONL$1);
+        LOGGER_SERVICE$4.debug(MARKDOWN_METHOD_NAME_USE_JSONL$1);
         this.useMarkdownAdapter(MarkdownFileBase);
     }
     /**
@@ -23406,7 +23430,7 @@ class MarkdownWriterAdapter {
      * so new storage instances are created with the updated base path.
      */
     clear() {
-        LOGGER_SERVICE$3.log(MARKDOWN_METHOD_NAME_CLEAR$1);
+        LOGGER_SERVICE$4.log(MARKDOWN_METHOD_NAME_CLEAR$1);
         this.getMarkdownStorage.clear();
     }
     /**
@@ -23414,7 +23438,7 @@ class MarkdownWriterAdapter {
      * All future markdown writes will be no-ops.
      */
     useDummy() {
-        LOGGER_SERVICE$3.debug(MARKDOWN_METHOD_NAME_USE_DUMMY$1);
+        LOGGER_SERVICE$4.debug(MARKDOWN_METHOD_NAME_USE_DUMMY$1);
         this.useMarkdownAdapter(MarkdownDummy);
     }
 }
@@ -23475,7 +23499,7 @@ class ReportBase {
                 });
             }
         }, 15000));
-        LOGGER_SERVICE$3.debug(REPORT_BASE_METHOD_NAME_CTOR, {
+        LOGGER_SERVICE$4.debug(REPORT_BASE_METHOD_NAME_CTOR, {
             reportName: this.reportName,
             baseDir,
         });
@@ -23489,7 +23513,7 @@ class ReportBase {
      * @returns Promise that resolves when initialization is complete
      */
     async waitForInit(initial) {
-        LOGGER_SERVICE$3.debug(REPORT_BASE_METHOD_NAME_WAIT_FOR_INIT, {
+        LOGGER_SERVICE$4.debug(REPORT_BASE_METHOD_NAME_WAIT_FOR_INIT, {
             reportName: this.reportName,
             initial,
         });
@@ -23508,7 +23532,7 @@ class ReportBase {
      * @throws Error if stream not initialized or write timeout exceeded
      */
     async write(data, options) {
-        LOGGER_SERVICE$3.debug(REPORT_BASE_METHOD_NAME_WRITE, {
+        LOGGER_SERVICE$4.debug(REPORT_BASE_METHOD_NAME_WRITE, {
             reportName: this.reportName,
             options,
         });
@@ -23605,7 +23629,7 @@ class ReportWriterAdapter {
          * @internal - Automatically called by report services, not for direct use
          */
         this.writeData = async (reportName, data, options) => {
-            LOGGER_SERVICE$3.info(REPORT_UTILS_METHOD_NAME_WRITE_DATA, {
+            LOGGER_SERVICE$4.info(REPORT_UTILS_METHOD_NAME_WRITE_DATA, {
                 reportName,
                 options,
             });
@@ -23622,7 +23646,7 @@ class ReportWriterAdapter {
      * @param Ctor - Constructor for report storage adapter
      */
     useReportAdapter(Ctor) {
-        LOGGER_SERVICE$3.info(REPORT_UTILS_METHOD_NAME_USE_REPORT_ADAPTER$1);
+        LOGGER_SERVICE$4.info(REPORT_UTILS_METHOD_NAME_USE_REPORT_ADAPTER$1);
         this.ReportFactory = Ctor;
     }
     /**
@@ -23631,7 +23655,7 @@ class ReportWriterAdapter {
      * so new storage instances are created with the updated base path.
      */
     clear() {
-        LOGGER_SERVICE$3.log(REPORT_UTILS_METHOD_NAME_CLEAR$1);
+        LOGGER_SERVICE$4.log(REPORT_UTILS_METHOD_NAME_CLEAR$1);
         this.getReportStorage.clear();
     }
     /**
@@ -23639,7 +23663,7 @@ class ReportWriterAdapter {
      * All future report writes will be no-ops.
      */
     useDummy() {
-        LOGGER_SERVICE$3.log(REPORT_UTILS_METHOD_NAME_USE_DUMMY$1);
+        LOGGER_SERVICE$4.log(REPORT_UTILS_METHOD_NAME_USE_DUMMY$1);
         this.useReportAdapter(ReportDummy);
     }
     /**
@@ -23647,7 +23671,7 @@ class ReportWriterAdapter {
      * All future report writes will use JSONL storage.
      */
     useJsonl() {
-        LOGGER_SERVICE$3.log(REPORT_UTILS_METHOD_NAME_USE_JSONL$1);
+        LOGGER_SERVICE$4.log(REPORT_UTILS_METHOD_NAME_USE_JSONL$1);
         this.useReportAdapter(ReportBase);
     }
 }
@@ -23702,7 +23726,7 @@ const CREATE_FILE_NAME_FN$c = (symbol, strategyName, exchangeName, frameName, ti
  * @param value - Value to check
  * @returns true if value is unsafe, false otherwise
  */
-function isUnsafe$3(value) {
+function isUnsafe$4(value) {
     if (typeof value !== "number") {
         return true;
     }
@@ -23714,6 +23738,25 @@ function isUnsafe$3(value) {
     }
     return false;
 }
+/** Minimum closed signals required to annualize Sharpe / yearly returns / Calmar. */
+const MIN_SIGNALS_FOR_ANNUALIZATION$2 = 10;
+/** Minimum signals required for ANY ratio metric (Sharpe / Sortino / stdDev). Below this,
+ *  sample size is too small to estimate variance meaningfully. */
+const MIN_SIGNALS_FOR_RATIOS$2 = 10;
+/** Minimum calendar span (days) for trade-frequency extrapolation. */
+const MIN_CALENDAR_SPAN_DAYS$2 = 14;
+/** Hard cap on tradesPerYear — prevents absurd extrapolation from short windows / clustered trades. */
+const MAX_TRADES_PER_YEAR$2 = 365;
+/** Hard cap on |expectedYearlyReturns| percent. Compound interest on high avgPnl × frequency
+ *  blows up to mathematically correct but business-unrealistic values. ±100% = 2x equity —
+ *  anything above this we suspect is a noisy estimate, not a genuine edge. Above the cap → null. */
+const MAX_EXPECTED_YEARLY_RETURNS$2 = 100;
+/** Hard cap on |calmarRatio|. Prevents explosion when equityMaxDrawdown is near zero. */
+const MAX_CALMAR_RATIO$2 = 1000;
+/** Minimum stdDev required for Sharpe/Sortino computation. Identical-returns series produce
+ *  float-artifact stdDev (~1e-17) that's mathematically > 0 but spuriously inflates
+ *  sharpe to astronomical values. Treat any stdDev below this threshold as zero. */
+const STDDEV_EPSILON$2 = 1e-9;
 /**
  * Storage class for accumulating closed signals per strategy.
  * Maintains a list of all closed signals and provides methods to generate reports.
@@ -23767,65 +23810,190 @@ let ReportStorage$a = class ReportStorage {
                 recoveryFactor: null,
             };
         }
-        const totalSignals = this._signalList.length;
-        const winCount = this._signalList.filter((s) => s.pnl.pnlPercentage > 0).length;
-        const lossCount = this._signalList.filter((s) => s.pnl.pnlPercentage < 0).length;
-        // Calculate basic statistics
-        const avgPnl = this._signalList.reduce((sum, s) => sum + s.pnl.pnlPercentage, 0) / totalSignals;
-        const totalPnl = this._signalList.reduce((sum, s) => sum + s.pnl.pnlPercentage, 0);
-        const winRate = (winCount / totalSignals) * 100;
-        // Calculate Sharpe Ratio (risk-free rate = 0)
-        const returns = this._signalList.map((s) => s.pnl.pnlPercentage);
-        const variance = returns.reduce((sum, r) => sum + Math.pow(r - avgPnl, 2), 0) / totalSignals;
-        const stdDev = Math.sqrt(variance);
-        const sharpeRatio = stdDev > 0 ? avgPnl / stdDev : 0;
-        const annualizedSharpeRatio = sharpeRatio * Math.sqrt(365);
-        // Calculate Certainty Ratio
-        const wins = this._signalList.filter((s) => s.pnl.pnlPercentage > 0);
-        const losses = this._signalList.filter((s) => s.pnl.pnlPercentage < 0);
+        // Valid signal set — those with usable pendingAt AND closeTimestamp. Single source
+        // of truth for EVERY metric in this method (counts, sums, span, equity curve,
+        // ratios, annualization). If we used different subsets for different metrics, the
+        // numerator of one ratio could be drawn from a different population than the
+        // denominator of another and the report would silently lie. On clean data
+        // validSignals === this._signalList; the filter only matters for corrupted runtime
+        // data.
+        const validSignals = this._signalList.filter((s) => typeof s.signal.pendingAt === "number" && s.signal.pendingAt > 0 &&
+            typeof s.closeTimestamp === "number" && s.closeTimestamp > 0);
+        const totalSignals = validSignals.length;
+        const winCount = validSignals.filter((s) => s.pnl.pnlPercentage > 0).length;
+        const lossCount = validSignals.filter((s) => s.pnl.pnlPercentage < 0).length;
+        // Basic statistics — guard against an empty validSignals (e.g. every signal had
+        // corrupted timestamps) so we don't divide by zero.
+        const avgPnl = totalSignals > 0
+            ? validSignals.reduce((sum, s) => sum + s.pnl.pnlPercentage, 0) / totalSignals
+            : 0;
+        const totalPnl = validSignals.reduce((sum, s) => sum + s.pnl.pnlPercentage, 0);
+        // Win rate excludes break-even trades from both numerator and denominator.
+        const decisiveTrades = winCount + lossCount;
+        const winRate = decisiveTrades > 0 ? (winCount / decisiveTrades) * 100 : 0;
+        // Calendar span over the same validSignals set used for ratios.
+        let firstPendingAt = Infinity;
+        let lastCloseAt = -Infinity;
+        for (const s of validSignals) {
+            if (s.signal.pendingAt < firstPendingAt)
+                firstPendingAt = s.signal.pendingAt;
+            if (s.closeTimestamp > lastCloseAt)
+                lastCloseAt = s.closeTimestamp;
+        }
+        const calendarSpanDays = isFinite(firstPendingAt) && isFinite(lastCloseAt)
+            ? (lastCloseAt - firstPendingAt) / (1000 * 60 * 60 * 24)
+            : 0;
+        // tradesPerYear uses the RAW observed frequency — no clipping. Clipping would
+        // silently understate Sharpe / Calmar / expectedYearlyReturns. Instead, if the
+        // raw frequency exceeds MAX_TRADES_PER_YEAR we treat the sample as too clustered
+        // for reliable annualization and surface every annualized metric as null.
+        const rawTradesPerYear = totalSignals >= MIN_SIGNALS_FOR_ANNUALIZATION$2 &&
+            calendarSpanDays >= MIN_CALENDAR_SPAN_DAYS$2
+            ? (totalSignals / calendarSpanDays) * 365
+            : 0;
+        const canAnnualize = rawTradesPerYear > 0 && rawTradesPerYear <= MAX_TRADES_PER_YEAR$2;
+        const tradesPerYear = canAnnualize ? rawTradesPerYear : 0;
+        // Per-trade Sharpe Ratio (risk-free rate = 0). Sample stddev (N-1) for unbiased estimate.
+        // Per-trade ratios are gated by MIN_SIGNALS_FOR_RATIOS — below that, variance estimates
+        // are too noisy to publish (high chance of spurious ±Sharpe).
+        const returns = validSignals.map((s) => s.pnl.pnlPercentage);
+        const canComputeRatios = totalSignals >= MIN_SIGNALS_FOR_RATIOS$2;
+        const stdDev = canComputeRatios
+            ? Math.sqrt(returns.reduce((sum, r) => sum + Math.pow(r - avgPnl, 2), 0) / (totalSignals - 1))
+            : 0;
+        // Use STDDEV_EPSILON gate (not stdDev > 0) — identical-returns series produce
+        // float-artifact stdDev (~1e-17) that's mathematically > 0 but spuriously
+        // inflates sharpe to astronomical magnitudes (avgPnl / epsilon).
+        const sharpeRatio = canComputeRatios && stdDev > STDDEV_EPSILON$2
+            ? avgPnl / stdDev
+            : null;
+        // Annualize only when gate passes; otherwise null.
+        const annualizedSharpeRatio = canAnnualize && sharpeRatio !== null
+            ? sharpeRatio * Math.sqrt(tradesPerYear)
+            : null;
+        // Equity-curve max drawdown via compounded equity (multiplicative, not additive).
+        // Returns are per-trade on cost basis — compounding assumes equal capital allocation
+        // per trade ("as-if 100% allocation"). Walks validSignals in chronological order
+        // (storage is newest-first, so iterate in reverse). Using validSignals (same set as
+        // tradesPerYear) keeps equityFinal consistent with the annualization exponent.
+        // If equity goes ≤ 0 (e.g. leveraged short with r < -100%) — account blown,
+        // fix DD at 100% and stop walking the curve.
+        let equity = 1;
+        let peak = 1;
+        let equityMaxDrawdown = 0;
+        let blown = false;
+        for (let i = validSignals.length - 1; i >= 0; i--) {
+            equity *= 1 + validSignals[i].pnl.pnlPercentage / 100;
+            if (equity <= 0) {
+                equityMaxDrawdown = 100;
+                blown = true;
+                break;
+            }
+            if (equity > peak)
+                peak = equity;
+            const dd = (peak - equity) / peak * 100;
+            if (dd > equityMaxDrawdown)
+                equityMaxDrawdown = dd;
+        }
+        const equityFinal = blown ? 0 : equity;
+        // Compounded yearly return via geometric mean of equity curve.
+        // equityFinal^(tradesPerYear / N) - 1 — accounts for volatility drag that
+        // arithmetic-mean compounding ((1+avgPnl)^N) misses. If account is blown, full loss.
+        // If the raw value would exceed MAX_EXPECTED_YEARLY_RETURNS, return null rather than
+        // showing the cap as a real figure — capped numbers mislead users into trusting them.
+        const expectedYearlyReturns = canAnnualize
+            ? blown
+                ? -100
+                : (() => {
+                    // Geometric annualization uses validSignals.length (same set that defined
+                    // tradesPerYear); using totalSignals here would mismatch numerator/denominator.
+                    const raw = (Math.pow(equityFinal, tradesPerYear / validSignals.length) - 1) * 100;
+                    return Math.abs(raw) > MAX_EXPECTED_YEARLY_RETURNS$2 ? null : raw;
+                })()
+            : null;
+        // Certainty Ratio — over validSignals so wins/losses come from the same set as
+        // winCount/lossCount/avgPnl above.
+        const wins = validSignals.filter((s) => s.pnl.pnlPercentage > 0);
+        const losses = validSignals.filter((s) => s.pnl.pnlPercentage < 0);
         const avgWin = wins.length > 0
             ? wins.reduce((sum, s) => sum + s.pnl.pnlPercentage, 0) / wins.length
             : 0;
         const avgLoss = losses.length > 0
             ? losses.reduce((sum, s) => sum + s.pnl.pnlPercentage, 0) / losses.length
             : 0;
-        const certaintyRatio = avgLoss < 0 ? avgWin / Math.abs(avgLoss) : 0;
-        // Calculate Expected Yearly Returns
-        const avgDurationMs = this._signalList.reduce((sum, s) => sum + (s.closeTimestamp - s.signal.pendingAt), 0) / totalSignals;
-        const avgDurationDays = avgDurationMs / (1000 * 60 * 60 * 24);
-        const tradesPerYear = avgDurationDays > 0 ? 365 / avgDurationDays : 0;
-        const expectedYearlyReturns = avgPnl * tradesPerYear;
-        // Calculate average peak and fall PNL across all signals
-        const avgPeakPnl = this._signalList.reduce((sum, s) => sum + (s.signal.peakProfit?.pnlPercentage ?? 0), 0) / totalSignals;
-        const avgFallPnl = this._signalList.reduce((sum, s) => sum + (s.signal.maxDrawdown?.pnlPercentage ?? 0), 0) / totalSignals;
-        // Downside per signal: maxDrawdown.pnlPercentage captures the worst intra-trade dip
-        const fallReturns = this._signalList.map((s) => s.signal.maxDrawdown?.pnlPercentage ?? 0);
-        // Calculate Sortino Ratio: avgPnl / stdDev(maxDrawdown per signal)
-        const fallVariance = fallReturns.reduce((sum, r) => sum + Math.pow(r, 2), 0) / totalSignals;
-        const fallDeviation = Math.sqrt(fallVariance);
-        const sortinoRatio = fallDeviation > 0 ? avgPnl / fallDeviation : 0;
-        // Max absolute drawdown across all signals — used as denominator for Calmar and Recovery
-        const maxAbsFall = fallReturns.reduce((max, r) => Math.max(max, Math.abs(r)), 0);
-        const calmarRatio = maxAbsFall > 0 ? expectedYearlyReturns / maxAbsFall : 0;
-        const recoveryFactor = maxAbsFall > 0 ? totalPnl / maxAbsFall : 0;
+        // Null below MIN_SIGNALS_FOR_RATIOS — on a handful of trades the win/loss
+        // means are too noisy to publish a ratio (same sample-size gate as Sharpe/
+        // Sortino, so the report doesn't surface certainty while withholding the rest).
+        // Also null when no losing trades OR when |avgLoss| is below STDDEV_EPSILON
+        // (float-artifact losses (-1e-15) would otherwise produce a spurious
+        // astronomical certaintyRatio ≈1e14).
+        const certaintyRatio = canComputeRatios && Math.abs(avgLoss) > STDDEV_EPSILON$2 && avgLoss < 0
+            ? avgWin / Math.abs(avgLoss)
+            : null;
+        // Average peak/fall PNL — over validSignals; only signals that actually have the
+        // value contribute (no zero dilution from missing peakProfit/maxDrawdown).
+        const peakValues = validSignals
+            .map((s) => s.signal.peakProfit?.pnlPercentage)
+            .filter((v) => typeof v === "number");
+        const fallValues = validSignals
+            .map((s) => s.signal.maxDrawdown?.pnlPercentage)
+            .filter((v) => typeof v === "number");
+        const avgPeakPnl = peakValues.length > 0
+            ? peakValues.reduce((sum, v) => sum + v, 0) / peakValues.length
+            : null;
+        const avgFallPnl = fallValues.length > 0
+            ? fallValues.reduce((sum, v) => sum + v, 0) / fallValues.length
+            : null;
+        // Sortino (canonical, Sortino 1991): (avgPnl - MAR) / downside deviation, where
+        // downsideDev = √( Σ min(0, r - MAR)² / N_total ). We use MAR = 0 (risk-free target),
+        // so the numerator reduces to avgPnl and the squared term to r² for r < 0.
+        // Dividing by N_total (not N_negative) properly penalises strategies with frequent
+        // losses; the "modified" form (N_negative) hides frequency risk in catastrophic-tail
+        // strategies.
+        const negativeReturns = returns.filter((r) => r < 0);
+        const sortinoRatio = (() => {
+            if (!canComputeRatios)
+                return null;
+            if (negativeReturns.length === 0)
+                return null;
+            const downsideVariance = negativeReturns.reduce((sum, r) => sum + r * r, 0) / returns.length;
+            const downsideDeviation = Math.sqrt(downsideVariance);
+            // Same epsilon guard as Sharpe — protects against float-artifact downsideDev.
+            return downsideDeviation > STDDEV_EPSILON$2 ? avgPnl / downsideDeviation : null;
+        })();
+        // Calmar — cap |value| at MAX_CALMAR_RATIO to prevent explosion when DD is near zero.
+        const calmarRatio = equityMaxDrawdown > 0 && expectedYearlyReturns !== null
+            ? Math.max(-MAX_CALMAR_RATIO$2, Math.min(MAX_CALMAR_RATIO$2, expectedYearlyReturns / equityMaxDrawdown))
+            : null;
+        // Recovery Factor: numerator must be the compounded total return (equityFinal − 1) × 100,
+        // not the arithmetic totalPnl — denominator (equityMaxDrawdown) is from the compounded
+        // curve, so mixing units would inflate Recovery on long winning streaks.
+        // Null below MIN_SIGNALS_FOR_RATIOS — same sample-size gate as the other ratios,
+        // so a 3-trade run doesn't surface a Recovery Factor while Sharpe/Calmar are N/A.
+        // Null when account is blown — ratio is meaningless after total loss.
+        // Same MAX_CALMAR_RATIO clamp as Calmar — both are compounded-profit/DD ratios
+        // and explode the same way when DD is near zero.
+        const recoveryFactor = !canComputeRatios || blown || equityMaxDrawdown <= 0
+            ? null
+            : Math.max(-MAX_CALMAR_RATIO$2, Math.min(MAX_CALMAR_RATIO$2, ((equityFinal - 1) * 100) / equityMaxDrawdown));
         return {
             signalList: this._signalList,
             totalSignals,
             winCount,
             lossCount,
-            winRate: isUnsafe$3(winRate) ? null : winRate,
-            avgPnl: isUnsafe$3(avgPnl) ? null : avgPnl,
-            totalPnl: isUnsafe$3(totalPnl) ? null : totalPnl,
-            stdDev: isUnsafe$3(stdDev) ? null : stdDev,
-            sharpeRatio: isUnsafe$3(sharpeRatio) ? null : sharpeRatio,
-            annualizedSharpeRatio: isUnsafe$3(annualizedSharpeRatio) ? null : annualizedSharpeRatio,
-            certaintyRatio: isUnsafe$3(certaintyRatio) ? null : certaintyRatio,
-            expectedYearlyReturns: isUnsafe$3(expectedYearlyReturns) ? null : expectedYearlyReturns,
-            avgPeakPnl: isUnsafe$3(avgPeakPnl) ? null : avgPeakPnl,
-            avgFallPnl: isUnsafe$3(avgFallPnl) ? null : avgFallPnl,
-            sortinoRatio: isUnsafe$3(sortinoRatio) ? null : sortinoRatio,
-            calmarRatio: isUnsafe$3(calmarRatio) ? null : calmarRatio,
-            recoveryFactor: isUnsafe$3(recoveryFactor) ? null : recoveryFactor,
+            winRate: isUnsafe$4(winRate) ? null : winRate,
+            avgPnl: isUnsafe$4(avgPnl) ? null : avgPnl,
+            totalPnl: isUnsafe$4(totalPnl) ? null : totalPnl,
+            stdDev: isUnsafe$4(stdDev) ? null : stdDev,
+            sharpeRatio: isUnsafe$4(sharpeRatio) ? null : sharpeRatio,
+            annualizedSharpeRatio: isUnsafe$4(annualizedSharpeRatio) ? null : annualizedSharpeRatio,
+            certaintyRatio: isUnsafe$4(certaintyRatio) ? null : certaintyRatio,
+            expectedYearlyReturns: isUnsafe$4(expectedYearlyReturns) ? null : expectedYearlyReturns,
+            avgPeakPnl: isUnsafe$4(avgPeakPnl) ? null : avgPeakPnl,
+            avgFallPnl: isUnsafe$4(avgFallPnl) ? null : avgFallPnl,
+            sortinoRatio: isUnsafe$4(sortinoRatio) ? null : sortinoRatio,
+            calmarRatio: isUnsafe$4(calmarRatio) ? null : calmarRatio,
+            recoveryFactor: isUnsafe$4(recoveryFactor) ? null : recoveryFactor,
         };
     }
     /**
@@ -23867,24 +24035,26 @@ let ReportStorage$a = class ReportStorage {
             `**Total PNL:** ${stats.totalPnl === null ? "N/A" : `${stats.totalPnl > 0 ? "+" : ""}${stats.totalPnl.toFixed(2)}% (higher is better)`}`,
             `**Standard Deviation:** ${stats.stdDev === null ? "N/A" : `${stats.stdDev.toFixed(3)}% (lower is better)`}`,
             `**Sharpe Ratio:** ${stats.sharpeRatio === null ? "N/A" : `${stats.sharpeRatio.toFixed(3)} (higher is better)`}`,
-            `**Annualized Sharpe Ratio:** ${stats.annualizedSharpeRatio === null ? "N/A" : `${stats.annualizedSharpeRatio.toFixed(3)} (higher is better, theoretical)`}`,
+            `**Annualized Sharpe Ratio:** ${stats.annualizedSharpeRatio === null ? "N/A" : `${stats.annualizedSharpeRatio.toFixed(3)} (higher is better)`}`,
             `**Certainty Ratio:** ${stats.certaintyRatio === null ? "N/A" : `${stats.certaintyRatio.toFixed(3)} (higher is better)`}`,
-            `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better, theoretical)`}`,
+            `**Expected Yearly Returns:** ${stats.expectedYearlyReturns === null ? "N/A" : `${stats.expectedYearlyReturns > 0 ? "+" : ""}${stats.expectedYearlyReturns.toFixed(2)}% (higher is better)`}`,
             `**Avg Peak PNL:** ${stats.avgPeakPnl === null ? "N/A" : `${stats.avgPeakPnl > 0 ? "+" : ""}${stats.avgPeakPnl.toFixed(2)}% (higher is better)`}`,
             `**Avg Max Drawdown PNL:** ${stats.avgFallPnl === null ? "N/A" : `${stats.avgFallPnl.toFixed(2)}% (closer to 0 is better)`}`,
             `**Sortino Ratio:** ${stats.sortinoRatio === null ? "N/A" : `${stats.sortinoRatio.toFixed(3)} (higher is better)`}`,
-            `**Calmar Ratio:** ${stats.calmarRatio === null ? "N/A" : `${stats.calmarRatio.toFixed(3)} (higher is better, theoretical)`}`,
+            `**Calmar Ratio:** ${stats.calmarRatio === null ? "N/A" : `${stats.calmarRatio.toFixed(3)} (higher is better)`}`,
             `**Recovery Factor:** ${stats.recoveryFactor === null ? "N/A" : `${stats.recoveryFactor.toFixed(3)} (higher is better)`}`,
             "",
             `*Win Rate: reliable above 200+ signals; below 30 signals a single streak can shift it by 10-20%.*`,
             `*Sharpe Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals.*`,
-            `*Annualized Sharpe Ratio: theoretical maximum assuming continuous trading. Real-world value is lower due to idle periods.*`,
-            `*Sortino Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals.*`,
+            `*Annualized Sharpe Ratio: per-trade Sharpe × √tradesPerYear; tradesPerYear = signals × 365 / calendarSpanDays. N/A unless ≥${MIN_SIGNALS_FOR_ANNUALIZATION$2} signals and span ≥${MIN_CALENDAR_SPAN_DAYS$2} days. Assumes returns are iid — autocorrelated strategies are overstated.*`,
+            `*Sortino Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals. N/A when no losing trades — Sortino is mathematically undefined (infinite) and we cannot distinguish "truly flawless" from "lucky streak so far".*`,
             `*Certainty Ratio: below 1.0 means average loss exceeds average win. Above 1.5 is considered good.*`,
-            `*Expected Yearly Returns: theoretical maximum assuming all capital is deployed continuously with no idle time.*`,
-            `*Calmar Ratio: below 0.5 is poor, 0.5-1.0 is acceptable, above 1.0 is strong. Based on theoretical yearly returns.*`,
-            `*Recovery Factor: below 1.0 means total profit does not cover max drawdown. Above 3.0 is considered good.*`,
-            `*All metrics require 100+ signals to be statistically reliable. Time period matters only for Annualized Sharpe Ratio and Expected Yearly Returns — they assume current market conditions hold year-round, which may not reflect reality.*`,
+            `*Expected Yearly Returns: compounded geometric return from the equity curve, annualized by tradesPerYear. Same gating as Annualized Sharpe. Capped at ±${MAX_EXPECTED_YEARLY_RETURNS$2}% — values above the cap return N/A.*`,
+            `*Calmar Ratio: below 0.5 is poor, 0.5-1.0 is acceptable, above 1.0 is strong. Denominator is compounded equity-curve max drawdown. Capped at ±${MAX_CALMAR_RATIO$2}.*`,
+            `*Recovery Factor: below 1.0 means total profit does not cover max drawdown. Above 3.0 is considered good. Uses compounded total return as numerator.*`,
+            `*All metrics require 100+ signals to be statistically reliable. Annualized metrics assume the observed trading frequency and market conditions persist year-round.*`,
+            `*IMPORTANT: Equity curve, Expected Yearly Returns, Calmar, Recovery and Max Drawdown all assume **100% capital allocation per trade** (no sizing, no portfolio fraction). Per-trade pnlPercentage is treated as a return on full equity. If your strategy risks X% of capital per trade, the realized portfolio return / drawdown will be roughly X/100 of the reported figures. The framework does not track portfolio-level sizing, so these metrics represent a theoretical upper bound under full allocation.*`,
+            `*Negative values for Sharpe / Sortino / Calmar / Recovery / Expected Yearly Returns indicate a losing strategy (avgPnl < 0 or totalPnl < 0). "Higher is better" still applies — closer to zero is less bad, positive is profitable.*`,
         ].join("\n");
     }
     /**
@@ -24196,7 +24366,7 @@ const CREATE_FILE_NAME_FN$b = (symbol, strategyName, exchangeName, frameName, ti
  * @param value - Value to check
  * @returns true if value is unsafe, false otherwise
  */
-function isUnsafe$2(value) {
+function isUnsafe$3(value) {
     if (typeof value !== "number") {
         return true;
     }
@@ -24208,6 +24378,25 @@ function isUnsafe$2(value) {
     }
     return false;
 }
+/** Minimum closed signals required to annualize Sharpe / yearly returns / Calmar. */
+const MIN_SIGNALS_FOR_ANNUALIZATION$1 = 10;
+/** Minimum signals required for ANY ratio metric (Sharpe / Sortino / stdDev). Below this,
+ *  sample size is too small to estimate variance meaningfully. */
+const MIN_SIGNALS_FOR_RATIOS$1 = 10;
+/** Minimum calendar span (days) for trade-frequency extrapolation. */
+const MIN_CALENDAR_SPAN_DAYS$1 = 14;
+/** Hard cap on tradesPerYear — prevents absurd extrapolation from short windows / clustered trades. */
+const MAX_TRADES_PER_YEAR$1 = 365;
+/** Hard cap on |expectedYearlyReturns| percent. Compound interest on high avgPnl × frequency
+ *  blows up to mathematically correct but business-unrealistic values. ±100% = 2x equity —
+ *  anything above this we suspect is a noisy estimate, not a genuine edge. Above the cap → null. */
+const MAX_EXPECTED_YEARLY_RETURNS$1 = 100;
+/** Hard cap on |calmarRatio|. Prevents explosion when equityMaxDrawdown is near zero. */
+const MAX_CALMAR_RATIO$1 = 1000;
+/** Minimum stdDev required for Sharpe/Sortino. Identical-returns series produce
+ *  float-artifact stdDev (~1e-17) that's > 0 but spuriously inflates sharpe to
+ *  astronomical magnitudes (avgPnl / epsilon). */
+const STDDEV_EPSILON$1 = 1e-9;
 /**
  * Storage class for accumulating all tick events per strategy.
  * Maintains a chronological list of all events (idle, opened, active, closed).
@@ -24491,84 +24680,190 @@ let ReportStorage$9 = class ReportStorage {
             };
         }
         const closedEvents = this._eventList.filter((e) => e.action === "closed");
-        const totalClosed = closedEvents.length;
-        const winCount = closedEvents.filter((e) => e.pnl && e.pnl > 0).length;
-        const lossCount = closedEvents.filter((e) => e.pnl && e.pnl < 0).length;
-        // Calculate basic statistics
-        const avgPnl = totalClosed > 0
-            ? closedEvents.reduce((sum, e) => sum + (e.pnl || 0), 0) / totalClosed
+        // Valid closed set — single source of truth. Events must have numeric pnl AND valid
+        // timestamps. Win/loss counts, returns, calendar span, equity curve — all derived
+        // from this set so they cannot disagree.
+        const validClosed = closedEvents.filter((e) => typeof e.pnl === "number" &&
+            typeof e.timestamp === "number" &&
+            e.timestamp > 0 &&
+            typeof (e.pendingAt ?? e.timestamp) === "number");
+        const totalClosed = validClosed.length;
+        const winCount = validClosed.filter((e) => e.pnl > 0).length;
+        const lossCount = validClosed.filter((e) => e.pnl < 0).length;
+        const returns = validClosed.map((e) => e.pnl);
+        const avgPnl = returns.length > 0
+            ? returns.reduce((sum, r) => sum + r, 0) / returns.length
             : 0;
-        const totalPnl = closedEvents.reduce((sum, e) => sum + (e.pnl || 0), 0);
-        const winRate = (winCount / totalClosed) * 100;
-        // Calculate Sharpe Ratio (risk-free rate = 0)
-        let sharpeRatio = 0;
-        let stdDev = 0;
-        if (totalClosed > 0) {
-            const returns = closedEvents.map((e) => e.pnl || 0);
-            const variance = returns.reduce((sum, r) => sum + Math.pow(r - avgPnl, 2), 0) / totalClosed;
-            stdDev = Math.sqrt(variance);
-            sharpeRatio = stdDev > 0 ? avgPnl / stdDev : 0;
-        }
-        const annualizedSharpeRatio = sharpeRatio * Math.sqrt(365);
-        // Calculate Certainty Ratio
-        let certaintyRatio = 0;
-        if (totalClosed > 0) {
-            const wins = closedEvents.filter((e) => e.pnl && e.pnl > 0);
-            const losses = closedEvents.filter((e) => e.pnl && e.pnl < 0);
+        const totalPnl = returns.reduce((sum, r) => sum + r, 0);
+        // Win rate excludes break-even trades from both numerator and denominator.
+        const decisiveTrades = winCount + lossCount;
+        const winRate = decisiveTrades > 0 ? (winCount / decisiveTrades) * 100 : 0;
+        // Trade frequency from calendar span — gated by minimum span and sample size to
+        // suppress absurd annualization on short / sparse runs. Span built from validClosed
+        // so denominator (calendarSpanDays) and numerator (returns.length) come from the
+        // same event set.
+        let firstPendingAt = Infinity;
+        let lastCloseAt = -Infinity;
+        for (const e of validClosed) {
+            const startAt = e.pendingAt ?? e.timestamp;
+            if (startAt < firstPendingAt)
+                firstPendingAt = startAt;
+            if (e.timestamp > lastCloseAt)
+                lastCloseAt = e.timestamp;
+        }
+        const calendarSpanDays = validClosed.length > 0
+            ? (lastCloseAt - firstPendingAt) / (1000 * 60 * 60 * 24)
+            : 0;
+        // tradesPerYear uses the RAW observed frequency — no clipping. Clipping would
+        // silently understate Sharpe / Calmar / expectedYearlyReturns. Instead, if the
+        // raw frequency exceeds MAX_TRADES_PER_YEAR we treat the sample as too clustered
+        // for reliable annualization and surface every annualized metric as null.
+        const rawTradesPerYear = returns.length >= MIN_SIGNALS_FOR_ANNUALIZATION$1 &&
+            calendarSpanDays >= MIN_CALENDAR_SPAN_DAYS$1
+            ? (returns.length / calendarSpanDays) * 365
+            : 0;
+        const canAnnualize = rawTradesPerYear > 0 && rawTradesPerYear <= MAX_TRADES_PER_YEAR$1;
+        const tradesPerYear = canAnnualize ? rawTradesPerYear : 0;
+        // Per-trade Sharpe Ratio (risk-free rate = 0). Sample stddev (N-1).
+        // Per-trade ratios are gated by MIN_SIGNALS_FOR_RATIOS — below that, variance estimates
+        // are too noisy to publish (high chance of spurious ±Sharpe).
+        const canComputeRatios = returns.length >= MIN_SIGNALS_FOR_RATIOS$1;
+        const stdDev = canComputeRatios
+            ? Math.sqrt(returns.reduce((sum, r) => sum + Math.pow(r - avgPnl, 2), 0) / (returns.length - 1))
+            : 0;
+        // STDDEV_EPSILON guard — protects against float-artifact stdDev from identical
+        // returns producing spuriously astronomical sharpe.
+        const sharpeRatio = canComputeRatios && stdDev > STDDEV_EPSILON$1
+            ? avgPnl / stdDev
+            : null;
+        // Annualize only when gate passes; otherwise null.
+        const annualizedSharpeRatio = canAnnualize && sharpeRatio !== null
+            ? sharpeRatio * Math.sqrt(tradesPerYear)
+            : null;
+        // Certainty Ratio: null (not zero) when there are no losing trades — a flawless
+        // strategy has undefined Certainty Ratio, not "worst case zero". Computed on
+        // validClosed for consistency with other ratios.
+        // Gated below MIN_SIGNALS_FOR_RATIOS — same sample-size gate as Sharpe/Sortino,
+        // so the report doesn't surface certainty on a handful of trades while
+        // withholding the rest.
+        let certaintyRatio = null;
+        if (canComputeRatios && totalClosed > 0) {
+            const wins = validClosed.filter((e) => e.pnl > 0);
+            const losses = validClosed.filter((e) => e.pnl < 0);
             const avgWin = wins.length > 0
-                ? wins.reduce((sum, e) => sum + (e.pnl || 0), 0) / wins.length
+                ? wins.reduce((sum, e) => sum + e.pnl, 0) / wins.length
                 : 0;
             const avgLoss = losses.length > 0
-                ? losses.reduce((sum, e) => sum + (e.pnl || 0), 0) / losses.length
+                ? losses.reduce((sum, e) => sum + e.pnl, 0) / losses.length
                 : 0;
-            certaintyRatio = avgLoss < 0 ? avgWin / Math.abs(avgLoss) : 0;
-        }
-        // Calculate Expected Yearly Returns
-        let expectedYearlyReturns = 0;
-        if (totalClosed > 0) {
-            const avgDurationMin = closedEvents.reduce((sum, e) => sum + (e.duration || 0), 0) / totalClosed;
-            const avgDurationDays = avgDurationMin / (60 * 24);
-            const tradesPerYear = avgDurationDays > 0 ? 365 / avgDurationDays : 0;
-            expectedYearlyReturns = avgPnl * tradesPerYear;
-        }
-        const avgPeakPnl = totalClosed > 0
-            ? closedEvents.reduce((sum, e) => sum + (e.peakPnl || 0), 0) / totalClosed
-            : 0;
-        const avgFallPnl = totalClosed > 0
-            ? closedEvents.reduce((sum, e) => sum + (e.fallPnl || 0), 0) / totalClosed
-            : 0;
-        // Downside per signal: fallPnl captures the worst intra-trade dip (maxDrawdown.pnlPercentage)
-        const fallReturns = closedEvents.map((e) => e.fallPnl || 0);
-        // Calculate Sortino Ratio: avgPnl / stdDev(maxDrawdown per signal)
-        let sortinoRatio = 0;
-        if (totalClosed > 0) {
-            const fallVariance = fallReturns.reduce((sum, r) => sum + Math.pow(r, 2), 0) / totalClosed;
-            const fallDeviation = Math.sqrt(fallVariance);
-            sortinoRatio = fallDeviation > 0 ? avgPnl / fallDeviation : 0;
-        }
-        // Max absolute drawdown across all signals — denominator for Calmar and Recovery
-        const maxAbsFall = fallReturns.reduce((max, r) => Math.max(max, Math.abs(r)), 0);
-        const calmarRatio = maxAbsFall > 0 ? expectedYearlyReturns / maxAbsFall : 0;
-        const recoveryFactor = maxAbsFall > 0 ? totalPnl / maxAbsFall : 0;
+            // STDDEV_EPSILON guard on |avgLoss| protects against float-artifact
+            // losses producing spurious astronomical certaintyRatio.
+            certaintyRatio = Math.abs(avgLoss) > STDDEV_EPSILON$1 && avgLoss < 0
+                ? avgWin / Math.abs(avgLoss)
+                : null;
+        }
+        // Average only over signals that have the value — do not dilute the mean with zeros.
+        // Use validClosed to keep all metric denominators consistent.
+        const peakValues = validClosed
+            .map((e) => e.peakPnl)
+            .filter((v) => typeof v === "number");
+        const fallValues = validClosed
+            .map((e) => e.fallPnl)
+            .filter((v) => typeof v === "number");
+        const avgPeakPnl = peakValues.length > 0
+            ? peakValues.reduce((sum, v) => sum + v, 0) / peakValues.length
+            : null;
+        const avgFallPnl = fallValues.length > 0
+            ? fallValues.reduce((sum, v) => sum + v, 0) / fallValues.length
+            : null;
+        // Sortino (canonical, Sortino 1991): (avgPnl - MAR) / downside deviation, where
+        // downsideDev = √( Σ min(0, r - MAR)² / N_total ). We use MAR = 0 (risk-free target),
+        // so the numerator reduces to avgPnl and the squared term to r² for r < 0.
+        // Dividing by N_total (not N_negative) properly penalises strategies with frequent
+        // losses; the "modified" form (N_negative) hides frequency risk in catastrophic-tail
+        // strategies.
+        const sortinoRatio = (() => {
+            if (!canComputeRatios)
+                return null;
+            const negativeReturns = returns.filter((r) => r < 0);
+            if (negativeReturns.length === 0)
+                return null;
+            const downsideVariance = negativeReturns.reduce((sum, r) => sum + r * r, 0) / returns.length;
+            const downsideDeviation = Math.sqrt(downsideVariance);
+            // Same epsilon guard as Sharpe — protects against float-artifact downsideDev.
+            return downsideDeviation > STDDEV_EPSILON$1 ? avgPnl / downsideDeviation : null;
+        })();
+        // Equity-curve max drawdown via compounded equity (multiplicative). Returns are per-trade
+        // on cost basis — compounding assumes equal capital allocation per trade ("as-if 100%").
+        // If equity ≤ 0 (leveraged short with r < -100%) — account blown, fix DD at 100%.
+        // Built from validClosed (newest-first), iterated reverse for chronological order.
+        const chronologicalReturns = [];
+        for (let i = validClosed.length - 1; i >= 0; i--) {
+            chronologicalReturns.push(validClosed[i].pnl);
+        }
+        let equity = 1;
+        let peak = 1;
+        let equityMaxDrawdown = 0;
+        let blown = false;
+        for (const r of chronologicalReturns) {
+            equity *= 1 + r / 100;
+            if (equity <= 0) {
+                equityMaxDrawdown = 100;
+                blown = true;
+                break;
+            }
+            if (equity > peak)
+                peak = equity;
+            const dd = (peak - equity) / peak * 100;
+            if (dd > equityMaxDrawdown)
+                equityMaxDrawdown = dd;
+        }
+        const equityFinal = blown ? 0 : equity;
+        // Compounded yearly return via geometric mean of equity curve:
+        // equityFinal^(tradesPerYear / N) - 1 — accounts for volatility drag.
+        // If account is blown, full loss. If raw value exceeds MAX_EXPECTED_YEARLY_RETURNS,
+        // return null rather than showing the cap — capped numbers mislead users.
+        const expectedYearlyReturns = canAnnualize
+            ? blown
+                ? -100
+                : (() => {
+                    const raw = (Math.pow(equityFinal, tradesPerYear / returns.length) - 1) * 100;
+                    return Math.abs(raw) > MAX_EXPECTED_YEARLY_RETURNS$1 ? null : raw;
+                })()
+            : null;
+        // Calmar — cap |value| at MAX_CALMAR_RATIO to prevent explosion when DD is near zero.
+        const calmarRatio = equityMaxDrawdown > 0 && expectedYearlyReturns !== null
+            ? Math.max(-MAX_CALMAR_RATIO$1, Math.min(MAX_CALMAR_RATIO$1, expectedYearlyReturns / equityMaxDrawdown))
+            : null;
+        // Recovery Factor: numerator must be the compounded total return, not arithmetic totalPnl —
+        // denominator is from the compounded equity curve, so mixing units inflates Recovery.
+        // Null below MIN_SIGNALS_FOR_RATIOS — same sample-size gate as the other ratios,
+        // so a 3-trade run doesn't surface a Recovery Factor while Sharpe/Calmar are N/A.
+        // Null when account is blown.
+        // Same MAX_CALMAR_RATIO clamp as Calmar — both are compounded-profit/DD ratios
+        // and explode the same way when DD is near zero.
+        const recoveryFactor = !canComputeRatios || blown || equityMaxDrawdown <= 0
+            ? null
+            : Math.max(-MAX_CALMAR_RATIO$1, Math.min(MAX_CALMAR_RATIO$1, ((equityFinal - 1) * 100) / equityMaxDrawdown));
         return {
             eventList: this._eventList,
             totalEvents: this._eventList.length,
             totalClosed,
             winCount,
             lossCount,
-            winRate: isUnsafe$2(winRate) ? null : winRate,
-            avgPnl: isUnsafe$2(avgPnl) ? null : avgPnl,
-            totalPnl: isUnsafe$2(totalPnl) ? null : totalPnl,
-            stdDev: isUnsafe$2(stdDev) ? null : stdDev,
-            sharpeRatio: isUnsafe$2(sharpeRatio) ? null : sharpeRatio,
-            annualizedSharpeRatio: isUnsafe$2(annualizedSharpeRatio) ? null : annualizedSharpeRatio,
-            certaintyRatio: isUnsafe$2(certaintyRatio) ? null : certaintyRatio,
-            expectedYearlyReturns: isUnsafe$2(expectedYearlyReturns) ? null : expectedYearlyReturns,
-            avgPeakPnl: isUnsafe$2(avgPeakPnl) ? null : avgPeakPnl,
-            avgFallPnl: isUnsafe$2(avgFallPnl) ? null : avgFallPnl,
-            sortinoRatio: isUnsafe$2(sortinoRatio) ? null : sortinoRatio,
-            calmarRatio: isUnsafe$2(calmarRatio) ? null : calmarRatio,
-            recoveryFactor: isUnsafe$2(recoveryFactor) ? null : recoveryFactor,
+            winRate: isUnsafe$3(winRate) ? null : winRate,
+            avgPnl: isUnsafe$3(avgPnl) ? null : avgPnl,
+            totalPnl: isUnsafe$3(totalPnl) ? null : totalPnl,
+            stdDev: isUnsafe$3(stdDev) ? null : stdDev,
+            sharpeRatio: isUnsafe$3(sharpeRatio) ? null : sharpeRatio,
+            annualizedSharpeRatio: isUnsafe$3(annualizedSharpeRatio) ? null : annualizedSharpeRatio,
+            certaintyRatio: isUnsafe$3(certaintyRatio) ? null : certaintyRatio,
+            expectedYearlyReturns: isUnsafe$3(expectedYearlyReturns) ? null : expectedYearlyReturns,
+            avgPeakPnl: isUnsafe$3(avgPeakPnl) ? null : avgPeakPnl,
+            avgFallPnl: isUnsafe$3(avgFallPnl) ? null : avgFallPnl,
+            sortinoRatio: isUnsafe$3(sortinoRatio) ? null : sortinoRatio,
+            calmarRatio: isUnsafe$3(calmarRatio) ? null : calmarRatio,
+            recoveryFactor: isUnsafe$3(recoveryFactor) ? null : recoveryFactor,
         };
     }
     /**
@@ -24616,18 +24911,20 @@ let ReportStorage$9 = class ReportStorage {
             `**Avg Peak PNL:** ${stats.avgPeakPnl === null ? "N/A" : `${stats.avgPeakPnl > 0 ? "+" : ""}${stats.avgPeakPnl.toFixed(2)}% (higher is better)`}`,
             `**Avg Max Drawdown PNL:** ${stats.avgFallPnl === null ? "N/A" : `${stats.avgFallPnl.toFixed(2)}% (closer to 0 is better)`}`,
             `**Sortino Ratio:** ${stats.sortinoRatio === null ? "N/A" : `${stats.sortinoRatio.toFixed(3)} (higher is better)`}`,
-            `**Calmar Ratio:** ${stats.calmarRatio === null ? "N/A" : `${stats.calmarRatio.toFixed(3)} (higher is better, theoretical)`}`,
+            `**Calmar Ratio:** ${stats.calmarRatio === null ? "N/A" : `${stats.calmarRatio.toFixed(3)} (higher is better)`}`,
             `**Recovery Factor:** ${stats.recoveryFactor === null ? "N/A" : `${stats.recoveryFactor.toFixed(3)} (higher is better)`}`,
             "",
             `*Win Rate: reliable above 200+ signals; below 30 signals a single streak can shift it by 10-20%.*`,
             `*Sharpe Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals.*`,
-            `*Annualized Sharpe Ratio: theoretical maximum assuming continuous trading. Real-world value is lower due to idle periods.*`,
-            `*Sortino Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals.*`,
+            `*Annualized Sharpe Ratio: per-trade Sharpe × √tradesPerYear; tradesPerYear = signals × 365 / calendarSpanDays. N/A unless ≥${MIN_SIGNALS_FOR_ANNUALIZATION$1} signals and span ≥${MIN_CALENDAR_SPAN_DAYS$1} days. Assumes returns are iid — autocorrelated strategies are overstated.*`,
+            `*Sortino Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals. N/A when no losing trades — Sortino is mathematically undefined (infinite) and we cannot distinguish "truly flawless" from "lucky streak so far".*`,
             `*Certainty Ratio: below 1.0 means average loss exceeds average win. Above 1.5 is considered good.*`,
-            `*Expected Yearly Returns: theoretical maximum assuming all capital is deployed continuously with no idle time.*`,
-            `*Calmar Ratio: below 0.5 is poor, 0.5-1.0 is acceptable, above 1.0 is strong. Based on theoretical yearly returns.*`,
-            `*Recovery Factor: below 1.0 means total profit does not cover max drawdown. Above 3.0 is considered good.*`,
-            `*All metrics require 100+ signals to be statistically reliable. Time period matters only for Annualized Sharpe Ratio and Expected Yearly Returns — they assume current market conditions hold year-round, which may not reflect reality.*`,
+            `*Expected Yearly Returns: compounded geometric return from the equity curve, annualized by tradesPerYear. Same gating as Annualized Sharpe. Capped at ±${MAX_EXPECTED_YEARLY_RETURNS$1}% — values above the cap return N/A.*`,
+            `*Calmar Ratio: below 0.5 is poor, 0.5-1.0 is acceptable, above 1.0 is strong. Denominator is compounded equity-curve max drawdown. Capped at ±${MAX_CALMAR_RATIO$1}.*`,
+            `*Recovery Factor: below 1.0 means total profit does not cover max drawdown. Above 3.0 is considered good. Uses compounded total return as numerator.*`,
+            `*All metrics require 100+ signals to be statistically reliable. Annualized metrics assume the observed trading frequency and market conditions persist year-round.*`,
+            `*IMPORTANT: Equity curve, Expected Yearly Returns, Calmar, Recovery and Max Drawdown all assume **100% capital allocation per trade** (no sizing, no portfolio fraction). Per-trade pnlPercentage is treated as a return on full equity. If your strategy risks X% of capital per trade, the realized portfolio return / drawdown will be roughly X/100 of the reported figures. The framework does not track portfolio-level sizing, so these metrics represent a theoretical upper bound under full allocation.*`,
+            `*Negative values for Sharpe / Sortino / Calmar / Recovery / Expected Yearly Returns indicate a losing strategy (avgPnl < 0 or totalPnl < 0). "Higher is better" still applies — closer to zero is less bad, positive is profitable.*`,
         ].join("\n");
     }
     /**
@@ -25006,7 +25303,9 @@ let ReportStorage$8 = class ReportStorage {
      */
     addOpenedEvent(data) {
         const durationMs = data.signal.pendingAt - data.signal.scheduledAt;
-        const durationMin = Math.round(durationMs / 60000);
+        // Keep fractional minutes — rounding to whole minutes zeroed out sub-30s durations,
+        // which dragged high-frequency averages towards zero.
+        const durationMin = durationMs / 60000;
         const newEvent = {
             timestamp: data.signal.pendingAt,
             action: "opened",
@@ -25042,7 +25341,8 @@ let ReportStorage$8 = class ReportStorage {
      */
     addCancelledEvent(data) {
         const durationMs = data.closeTimestamp - data.signal.scheduledAt;
-        const durationMin = Math.round(durationMs / 60000);
+        // Keep fractional minutes — rounding to whole minutes zeroed out sub-30s durations.
+        const durationMin = durationMs / 60000;
         const newEvent = {
             timestamp: data.closeTimestamp,
             action: "cancelled",
@@ -25098,19 +25398,33 @@ let ReportStorage$8 = class ReportStorage {
         const totalScheduled = scheduledEvents.length;
         const totalOpened = openedEvents.length;
         const totalCancelled = cancelledEvents.length;
-        // Calculate cancellation rate
-        const cancellationRate = totalScheduled > 0 ? (totalCancelled / totalScheduled) * 100 : null;
-        // Calculate activation rate
-        const activationRate = totalScheduled > 0 ? (totalOpened / totalScheduled) * 100 : null;
-        // Calculate average wait time for cancelled signals
-        const avgWaitTime = totalCancelled > 0
-            ? cancelledEvents.reduce((sum, e) => sum + (e.duration || 0), 0) /
-                totalCancelled
+        // Rate denominators must include only scheduled events whose outcome (opened/cancelled)
+        // is also in the buffer. Otherwise a sliding window of 250 entries can drop the
+        // "scheduled" record before its outcome arrives, inflating rates above 100% or
+        // causing one rate to fire without the other. Match by signalId.
+        const scheduledIds = new Set(scheduledEvents.map((e) => e.signalId).filter((id) => typeof id === "string"));
+        const openedFromScheduled = openedEvents.filter((e) => typeof e.signalId === "string" && scheduledIds.has(e.signalId));
+        const cancelledFromScheduled = cancelledEvents.filter((e) => typeof e.signalId === "string" && scheduledIds.has(e.signalId));
+        const resolvedScheduled = openedFromScheduled.length + cancelledFromScheduled.length;
+        const cancellationRate = resolvedScheduled > 0
+            ? (cancelledFromScheduled.length / resolvedScheduled) * 100
+            : null;
+        const activationRate = resolvedScheduled > 0
+            ? (openedFromScheduled.length / resolvedScheduled) * 100
+            : null;
+        // Average durations — include only events with a numeric duration, do not dilute
+        // the mean with zeros for missing values.
+        const cancelledDurations = cancelledEvents
+            .map((e) => e.duration)
+            .filter((d) => typeof d === "number");
+        const openedDurations = openedEvents
+            .map((e) => e.duration)
+            .filter((d) => typeof d === "number");
+        const avgWaitTime = cancelledDurations.length > 0
+            ? cancelledDurations.reduce((sum, d) => sum + d, 0) / cancelledDurations.length
             : null;
-        // Calculate average activation time for opened signals
-        const avgActivationTime = totalOpened > 0
-            ? openedEvents.reduce((sum, e) => sum + (e.duration || 0), 0) /
-                totalOpened
+        const avgActivationTime = openedDurations.length > 0
+            ? openedDurations.reduce((sum, d) => sum + d, 0) / openedDurations.length
             : null;
         return {
             eventList: this._eventList,
@@ -25157,13 +25471,15 @@ let ReportStorage$8 = class ReportStorage {
             table,
             "",
             `**Total events:** ${stats.totalEvents}`,
-            `**Scheduled signals:** ${stats.totalScheduled}`,
+            `**Scheduled signals (raw):** ${stats.totalScheduled}`,
             `**Opened signals:** ${stats.totalOpened}`,
             `**Cancelled signals:** ${stats.totalCancelled}`,
             `**Activation rate:** ${stats.activationRate === null ? "N/A" : `${stats.activationRate.toFixed(2)}% (higher is better)`}`,
             `**Cancellation rate:** ${stats.cancellationRate === null ? "N/A" : `${stats.cancellationRate.toFixed(2)}% (lower is better)`}`,
             `**Average activation time:** ${stats.avgActivationTime === null ? "N/A" : `${stats.avgActivationTime.toFixed(2)} minutes`}`,
-            `**Average wait time (cancelled):** ${stats.avgWaitTime === null ? "N/A" : `${stats.avgWaitTime.toFixed(2)} minutes`}`
+            `**Average wait time (cancelled):** ${stats.avgWaitTime === null ? "N/A" : `${stats.avgWaitTime.toFixed(2)} minutes`}`,
+            "",
+            `*Activation / Cancellation rates are computed over scheduled signals whose outcome (opened or cancelled) is also in the buffer — matched by signalId. "Scheduled signals (raw)" above is the unmatched count and may include records whose outcome has not yet arrived or was evicted from the buffer.*`
         ].join("\n");
     }
     /**
@@ -25468,13 +25784,37 @@ const CREATE_FILE_NAME_FN$9 = (symbol, strategyName, exchangeName, frameName, ti
     return `${parts.join("_")}-${timestamp}.md`;
 };
 /**
- * Calculates percentile value from sorted array.
+ * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
+ */
+function isUnsafe$2(value) {
+    if (typeof value !== "number") {
+        return true;
+    }
+    if (isNaN(value)) {
+        return true;
+    }
+    if (!isFinite(value)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Calculates percentile value from sorted array using linear interpolation
+ * between adjacent ranks (equivalent to numpy.percentile with default linear method).
+ * Falls back to nearest-rank for length 0/1.
  */
 function percentile(sortedArray, p) {
     if (sortedArray.length === 0)
         return 0;
-    const index = Math.ceil((sortedArray.length * p) / 100) - 1;
-    return sortedArray[Math.max(0, index)];
+    if (sortedArray.length === 1)
+        return sortedArray[0];
+    const rank = (p / 100) * (sortedArray.length - 1);
+    const lower = Math.floor(rank);
+    const upper = Math.ceil(rank);
+    if (lower === upper)
+        return sortedArray[lower];
+    const fraction = rank - lower;
+    return sortedArray[lower] * (1 - fraction) + sortedArray[upper] * fraction;
 }
 /**
  * Storage class for accumulating performance metrics per strategy.
@@ -25530,10 +25870,12 @@ class PerformanceStorage {
             const durations = events.map((e) => e.duration).sort((a, b) => a - b);
             const totalDuration = durations.reduce((sum, d) => sum + d, 0);
             const avgDuration = totalDuration / durations.length;
-            // Calculate standard deviation
-            const variance = durations.reduce((sum, d) => sum + Math.pow(d - avgDuration, 2), 0) /
-                durations.length;
-            const stdDev = Math.sqrt(variance);
+            // Sample standard deviation (Bessel correction: divide by N-1, not N) — consistent
+            // with Sharpe/Sortino calculations in Backtest/Live/Heat services.
+            const stdDev = durations.length > 1
+                ? Math.sqrt(durations.reduce((sum, d) => sum + Math.pow(d - avgDuration, 2), 0) /
+                    (durations.length - 1))
+                : 0;
             // Calculate wait times between events
             const waitTimes = [];
             for (let i = 0; i < events.length; i++) {
@@ -25606,9 +25948,13 @@ class PerformanceStorage {
         const rows = await Promise.all(sortedMetrics.map(async (metric, index) => Promise.all(visibleColumns.map((col) => col.format(metric, index)))));
         const tableData = [header, separator, ...rows];
         const summaryTable = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
-        // Calculate percentage of total time for each metric
+        // Calculate percentage of total time for each metric. Guard against zero total
+        // duration (all-instant operations) to avoid NaN% in the rendered report.
         const percentages = sortedMetrics.map((metric) => {
-            const pct = (metric.totalDuration / stats.totalDuration) * 100;
+            const pctRaw = stats.totalDuration > 0
+                ? (metric.totalDuration / stats.totalDuration) * 100
+                : 0;
+            const pct = isUnsafe$2(pctRaw) ? 0 : pctRaw;
             return `- **${metric.metricType}**: ${pct.toFixed(1)}% (${metric.totalDuration.toFixed(2)}ms total)`;
         });
         return [
@@ -26377,6 +26723,25 @@ function isUnsafe(value) {
     }
     return false;
 }
+/** Minimum closed signals required to annualize Sharpe / yearly returns / Calmar. */
+const MIN_SIGNALS_FOR_ANNUALIZATION = 10;
+/** Minimum signals required for ANY ratio metric (Sharpe / Sortino / stdDev). Below this,
+ *  sample size is too small to estimate variance meaningfully. */
+const MIN_SIGNALS_FOR_RATIOS = 10;
+/** Minimum calendar span (days) for trade-frequency extrapolation. */
+const MIN_CALENDAR_SPAN_DAYS = 14;
+/** Hard cap on tradesPerYear — prevents absurd extrapolation from short windows / clustered trades. */
+const MAX_TRADES_PER_YEAR = 365;
+/** Hard cap on |expectedYearlyReturns| percent. Compound interest on high avgPnl × frequency
+ *  blows up to mathematically correct but business-unrealistic values. ±100% = 2x equity —
+ *  anything above this we suspect is a noisy estimate, not a genuine edge. Above the cap → null. */
+const MAX_EXPECTED_YEARLY_RETURNS = 100;
+/** Hard cap on |calmarRatio|. Prevents explosion when equityMaxDrawdown is near zero. */
+const MAX_CALMAR_RATIO = 1000;
+/** Minimum stdDev required for Sharpe/Sortino. Identical-returns series produce
+ *  float-artifact stdDev (~1e-17) that's > 0 but spuriously inflates sharpe to
+ *  astronomical magnitudes (avgPnl / epsilon). */
+const STDDEV_EPSILON = 1e-9;
 /**
  * Storage class for accumulating closed signals per strategy and generating heatmap.
  * Maintains symbol-level statistics and provides portfolio-wide metrics.
@@ -26418,7 +26783,7 @@ class HeatmapStorage {
      * - **totalPnl** — sum of `pnlPercentage` across all signals
      * - **avgPnl** — arithmetic mean of `pnlPercentage`
      * - **stdDev** — population standard deviation of `pnlPercentage`
-     * - **sharpeRatio** — `avgPnl / stdDev`; requires ≥ 2 signals and `stdDev > 0`
+     * - **sharpeRatio** — per-trade Sharpe: `avgPnl / stdDev`; requires ≥ 2 signals and `stdDev > 0`
      * - **maxDrawdown** — largest cumulative loss streak (absolute value of peak negative equity)
      * - **profitFactor** — `sumWins / |sumLosses|`; requires at least one win and one loss
      * - **avgWin / avgLoss** — mean of positive / negative trades respectively
@@ -26434,10 +26799,12 @@ class HeatmapStorage {
         const totalTrades = signals.length;
         const winCount = signals.filter((s) => s.pnl.pnlPercentage > 0).length;
         const lossCount = signals.filter((s) => s.pnl.pnlPercentage < 0).length;
-        // Calculate win rate
+        // Win rate excludes break-even trades from both numerator and denominator —
+        // they are neither wins nor losses.
         let winRate = null;
-        if (totalTrades > 0) {
-            winRate = (winCount / totalTrades) * 100;
+        const decisiveTrades = winCount + lossCount;
+        if (decisiveTrades > 0) {
+            winRate = (winCount / decisiveTrades) * 100;
         }
         // Calculate total PNL
         let totalPnl = null;
@@ -26449,36 +26816,47 @@ class HeatmapStorage {
         if (signals.length > 0) {
             avgPnl = totalPnl / signals.length;
         }
-        // Calculate standard deviation
+        // Sample standard deviation (Bessel correction: divide by N-1, not N).
+        // Per-symbol ratios are gated by MIN_SIGNALS_FOR_RATIOS — variance estimates from
+        // tiny samples are too noisy to publish.
+        const canComputeRatios = signals.length >= MIN_SIGNALS_FOR_RATIOS;
         let stdDev = null;
-        if (signals.length > 1 && avgPnl !== null) {
-            const variance = signals.reduce((acc, s) => acc + Math.pow(s.pnl.pnlPercentage - avgPnl, 2), 0) / signals.length;
+        if (canComputeRatios && avgPnl !== null) {
+            const variance = signals.reduce((acc, s) => acc + Math.pow(s.pnl.pnlPercentage - avgPnl, 2), 0) / (signals.length - 1);
             stdDev = Math.sqrt(variance);
         }
-        // Calculate Sharpe Ratio
+        // Per-trade Sharpe Ratio
         let sharpeRatio = null;
-        if (avgPnl !== null && stdDev !== null && stdDev !== 0) {
+        // STDDEV_EPSILON guard — protects against float-artifact stdDev producing
+        // spuriously astronomical sharpe on identical-returns symbols.
+        if (avgPnl !== null && stdDev !== null && stdDev > STDDEV_EPSILON) {
             sharpeRatio = avgPnl / stdDev;
         }
-        // Calculate Maximum Drawdown
+        // Equity-curve max drawdown via compounded equity ("as-if 100% allocation per trade").
+        // Signals are stored newest-first (unshift in addSignal), so iterate in reverse.
+        // If equity ≤ 0 — account blown, fix DD at 100%. equityFinal feeds expectedYearlyReturns.
         let maxDrawdown = null;
+        let equityFinal = 1;
+        let blown = false;
         if (signals.length > 0) {
-            let peak = 0;
-            let currentDrawdown = 0;
+            let equity = 1;
+            let peak = 1;
             let maxDD = 0;
-            for (const signal of signals) {
-                peak += signal.pnl.pnlPercentage;
-                if (peak > 0) {
-                    currentDrawdown = 0;
-                }
-                else {
-                    currentDrawdown = Math.abs(peak);
-                    if (currentDrawdown > maxDD) {
-                        maxDD = currentDrawdown;
-                    }
+            for (let i = signals.length - 1; i >= 0; i--) {
+                equity *= 1 + signals[i].pnl.pnlPercentage / 100;
+                if (equity <= 0) {
+                    maxDD = 100;
+                    blown = true;
+                    break;
                 }
+                if (equity > peak)
+                    peak = equity;
+                const dd = (peak - equity) / peak * 100;
+                if (dd > maxDD)
+                    maxDD = dd;
             }
             maxDrawdown = maxDD;
+            equityFinal = blown ? 0 : equity;
         }
         // Calculate Profit Factor
         let profitFactor = null;
@@ -26489,7 +26867,9 @@ class HeatmapStorage {
             const sumLosses = Math.abs(signals
                 .filter((s) => s.pnl.pnlPercentage < 0)
                 .reduce((acc, s) => acc + s.pnl.pnlPercentage, 0));
-            if (sumLosses > 0) {
+            // STDDEV_EPSILON guard — float-artifact losses (≈1e-15) would otherwise
+            // produce spurious astronomical profitFactor (≈1e14).
+            if (sumLosses > STDDEV_EPSILON) {
                 profitFactor = sumWins / sumLosses;
             }
         }
@@ -26529,45 +26909,110 @@ class HeatmapStorage {
                 }
             }
         }
-        // Calculate Expectancy
+        // Expectancy — probabilities from observed win/loss counts (break-evens contribute 0).
         let expectancy = null;
-        if (winRate !== null && avgWin !== null && avgLoss !== null) {
-            const lossRate = 100 - winRate;
-            expectancy = (winRate / 100) * avgWin + (lossRate / 100) * avgLoss;
+        if (totalTrades > 0 && avgWin !== null && avgLoss !== null) {
+            const winProb = winCount / totalTrades;
+            const lossProb = lossCount / totalTrades;
+            expectancy = winProb * avgWin + lossProb * avgLoss;
+        }
+        else if (totalTrades > 0 && avgWin !== null && avgLoss === null) {
+            // No losing trades — expectancy is just average win frequency × avgWin
+            expectancy = (winCount / totalTrades) * avgWin;
+        }
+        else if (totalTrades > 0 && avgWin === null && avgLoss !== null) {
+            expectancy = (lossCount / totalTrades) * avgLoss;
         }
-        // Calculate average peak and fall PNL
+        // Average only over signals that have the value — do not dilute the mean with zeros.
         let avgPeakPnl = null;
         let avgFallPnl = null;
         if (signals.length > 0) {
-            avgPeakPnl = signals.reduce((acc, s) => acc + (s.signal.peakProfit?.pnlPercentage ?? 0), 0) / signals.length;
-            avgFallPnl = signals.reduce((acc, s) => acc + (s.signal.maxDrawdown?.pnlPercentage ?? 0), 0) / signals.length;
+            const peakValues = signals
+                .map((s) => s.signal.peakProfit?.pnlPercentage)
+                .filter((v) => typeof v === "number");
+            const fallValues = signals
+                .map((s) => s.signal.maxDrawdown?.pnlPercentage)
+                .filter((v) => typeof v === "number");
+            avgPeakPnl = peakValues.length > 0
+                ? peakValues.reduce((sum, v) => sum + v, 0) / peakValues.length
+                : null;
+            avgFallPnl = fallValues.length > 0
+                ? fallValues.reduce((sum, v) => sum + v, 0) / fallValues.length
+                : null;
         }
-        // Downside per signal: maxDrawdown.pnlPercentage captures the worst intra-trade dip
-        const fallReturns = signals.map((s) => s.signal.maxDrawdown?.pnlPercentage ?? 0);
-        // Calculate Sortino Ratio: avgPnl / stdDev(maxDrawdown per signal)
+        // Sortino (canonical, Sortino 1991): (avgPnl - MAR) / downside deviation, where
+        // downsideDev = √( Σ min(0, r - MAR)² / N_total ). We use MAR = 0 (risk-free target),
+        // so the numerator reduces to avgPnl and the squared term to r² for r < 0.
+        // Dividing by N_total (not N_negative) properly penalises strategies with frequent
+        // losses; the "modified" form (N_negative) hides frequency risk in catastrophic-tail
+        // strategies.
         let sortinoRatio = null;
-        if (signals.length > 0 && avgPnl !== null) {
-            const fallVariance = fallReturns.reduce((acc, r) => acc + Math.pow(r, 2), 0) / signals.length;
-            const fallDeviation = Math.sqrt(fallVariance);
-            if (fallDeviation > 0) {
-                sortinoRatio = avgPnl / fallDeviation;
-            }
-        }
-        // Max absolute drawdown across all signals — denominator for Calmar and Recovery
-        const maxAbsFall = fallReturns.reduce((max, r) => Math.max(max, Math.abs(r)), 0);
-        // Expected yearly returns — needed for Calmar
-        let expectedYearlyReturns = 0;
-        if (signals.length > 0 && avgPnl !== null) {
-            const avgDurationMs = signals.reduce((sum, s) => sum + (s.closeTimestamp - s.signal.pendingAt), 0) / signals.length;
-            const avgDurationDays = avgDurationMs / (1000 * 60 * 60 * 24);
-            const tradesPerYear = avgDurationDays > 0 ? 365 / avgDurationDays : 0;
-            expectedYearlyReturns = avgPnl * tradesPerYear;
+        if (canComputeRatios && avgPnl !== null) {
+            const negativeReturns = signals
+                .map((s) => s.pnl.pnlPercentage)
+                .filter((r) => r < 0);
+            if (negativeReturns.length > 0) {
+                const downsideVariance = negativeReturns.reduce((acc, r) => acc + r * r, 0) / signals.length;
+                const downsideDeviation = Math.sqrt(downsideVariance);
+                // Same epsilon guard as Sharpe — protects against float-artifact downsideDev.
+                if (downsideDeviation > STDDEV_EPSILON) {
+                    sortinoRatio = avgPnl / downsideDeviation;
+                }
+            }
         }
+        // Expected yearly returns via geometric mean of equity curve.
+        // equityFinal^(tradesPerYear / N) - 1 — accounts for volatility drag.
+        // Gated by sample size and calendar span; if account blown → full loss.
+        let expectedYearlyReturns = null;
+        let tradesPerYear = null;
+        if (signals.length >= MIN_SIGNALS_FOR_ANNUALIZATION) {
+            let firstPendingAt = Infinity;
+            let lastCloseAt = -Infinity;
+            for (const s of signals) {
+                if (s.signal.pendingAt < firstPendingAt)
+                    firstPendingAt = s.signal.pendingAt;
+                if (s.closeTimestamp > lastCloseAt)
+                    lastCloseAt = s.closeTimestamp;
+            }
+            const calendarSpanDays = (lastCloseAt - firstPendingAt) / (1000 * 60 * 60 * 24);
+            if (calendarSpanDays >= MIN_CALENDAR_SPAN_DAYS) {
+                // tradesPerYear uses RAW observed frequency — no clipping. If the raw value
+                // exceeds MAX_TRADES_PER_YEAR the sample is too clustered for reliable
+                // annualization, and we leave the annualized metric null instead of silently
+                // understating it with a clipped frequency.
+                const rawTradesPerYear = (signals.length / calendarSpanDays) * 365;
+                if (rawTradesPerYear <= MAX_TRADES_PER_YEAR) {
+                    tradesPerYear = rawTradesPerYear;
+                    if (blown) {
+                        expectedYearlyReturns = -100;
+                    }
+                    else {
+                        // If raw value exceeds MAX_EXPECTED_YEARLY_RETURNS, leave null rather than
+                        // show the cap — capped numbers mislead users into trusting them.
+                        const raw = (Math.pow(equityFinal, tradesPerYear / signals.length) - 1) * 100;
+                        expectedYearlyReturns = Math.abs(raw) > MAX_EXPECTED_YEARLY_RETURNS ? null : raw;
+                    }
+                }
+            }
+        }
+        // Calmar = annualized return / equity-curve max drawdown, capped at ±MAX_CALMAR_RATIO.
+        // Recovery Factor uses the compounded total return (equityFinal-1)*100, not arithmetic
+        // totalPnl — denominator is compounded so numerator must match. Null when account blown.
         let calmarRatio = null;
         let recoveryFactor = null;
-        if (maxAbsFall > 0 && totalPnl !== null) {
-            calmarRatio = expectedYearlyReturns / maxAbsFall;
-            recoveryFactor = totalPnl / maxAbsFall;
+        if (maxDrawdown !== null && maxDrawdown > 0) {
+            if (expectedYearlyReturns !== null) {
+                const raw = expectedYearlyReturns / maxDrawdown;
+                calmarRatio = Math.max(-MAX_CALMAR_RATIO, Math.min(MAX_CALMAR_RATIO, raw));
+            }
+            if (!blown && canComputeRatios) {
+                // Gated below MIN_SIGNALS_FOR_RATIOS like Sharpe — a Recovery Factor on
+                // a handful of trades is statistically meaningless, so don't surface it
+                // per-symbol while Sharpe is N/A.
+                // Same MAX_CALMAR_RATIO clamp as Calmar — both compounded-profit/DD ratios.
+                const rawRec = ((equityFinal - 1) * 100) / maxDrawdown;
+                recoveryFactor = Math.max(-MAX_CALMAR_RATIO, Math.min(MAX_CALMAR_RATIO, rawRec));
+            }
         }
         // Apply safe math checks
         if (isUnsafe(winRate))
@@ -26632,12 +27077,18 @@ class HeatmapStorage {
      * 2. Sorts symbols by `sharpeRatio` descending — best performers first,
      *    symbols with `null` sharpeRatio placed at the end.
      * 3. Computes portfolio-wide aggregates:
-     *    - `portfolioTotalPnl` — sum of all per-symbol `totalPnl` values (treats `null` as 0)
-     *    - `portfolioTotalTrades` — sum of all per-symbol `totalTrades`
-     *    - `portfolioSharpeRatio` — trade-count-weighted average of per-symbol sharpe ratios
-     *
-     * @returns Promise resolving to `HeatmapStatisticsModel` with per-symbol rows and
-     *   portfolio-wide `portfolioTotalPnl`, `portfolioSharpeRatio`, `portfolioTotalTrades`
+     *    - `portfolioTotalPnl` — sum of per-symbol `totalPnl` values, skipping `null` entries
+     *      (so a symbol with no data does not silently contribute 0). If every symbol's
+     *      `totalPnl` is null, the portfolio value is null.
+     *    - `portfolioTotalTrades` — sum of per-symbol `totalTrades`
+     *    - `portfolioSharpeRatio` — POOLED Sharpe over all trades across symbols (sample
+     *      stddev, N-1). NOT a Markowitz portfolio Sharpe — ignores cross-symbol
+     *      correlations and capital allocation. Rendered as "Pooled Sharpe" in the report.
+     *      Gated by `MIN_SIGNALS_FOR_RATIOS` on the pooled count.
+     *    - `portfolioAvgPeakPnl` / `portfolioAvgFallPnl` — trade-count-weighted means
+     *      over symbols that have non-null values.
+     *
+     * @returns Promise resolving to `HeatmapStatisticsModel`
      */
     async getData() {
         const symbols = [];
@@ -26656,31 +27107,53 @@ class HeatmapStorage {
                 return -1;
             return b.sharpeRatio - a.sharpeRatio;
         });
-        // Calculate portfolio-wide metrics
+        // Portfolio totals — sum only over symbols with non-null totalPnl. `s.totalPnl || 0`
+        // would silently treat a missing value as zero and hide that some symbols had no data.
         const totalSymbols = symbols.length;
         let portfolioTotalPnl = null;
         let portfolioTotalTrades = 0;
         if (symbols.length > 0) {
-            portfolioTotalPnl = symbols.reduce((acc, s) => acc + (s.totalPnl || 0), 0);
+            const validTotalPnls = symbols.filter((s) => s.totalPnl !== null);
+            portfolioTotalPnl = validTotalPnls.length > 0
+                ? validTotalPnls.reduce((acc, s) => acc + s.totalPnl, 0)
+                : null;
             portfolioTotalTrades = symbols.reduce((acc, s) => acc + s.totalTrades, 0);
         }
-        // Calculate portfolio Sharpe Ratio (weighted by number of trades)
+        // Pooled Sharpe over all returns across symbols. NOTE: this is NOT a Markowitz
+        // portfolio Sharpe — it ignores cross-symbol correlations and treats trades as a
+        // single pooled sample. Gated by MIN_SIGNALS_FOR_RATIOS so a 2-trade pool cannot
+        // produce a noisy ±Sharpe.
         let portfolioSharpeRatio = null;
-        const validSharpes = symbols.filter((s) => s.sharpeRatio !== null);
-        if (validSharpes.length > 0 && portfolioTotalTrades > 0) {
-            const weightedSum = validSharpes.reduce((acc, s) => acc + s.sharpeRatio * s.totalTrades, 0);
-            portfolioSharpeRatio = weightedSum / portfolioTotalTrades;
+        const allReturns = [];
+        for (const signals of this.symbolData.values()) {
+            for (const s of signals) {
+                allReturns.push(s.pnl.pnlPercentage);
+            }
+        }
+        if (allReturns.length >= MIN_SIGNALS_FOR_RATIOS) {
+            const portfolioAvg = allReturns.reduce((acc, r) => acc + r, 0) / allReturns.length;
+            const portfolioVariance = allReturns.reduce((acc, r) => acc + Math.pow(r - portfolioAvg, 2), 0) /
+                (allReturns.length - 1);
+            const portfolioStdDev = Math.sqrt(portfolioVariance);
+            // STDDEV_EPSILON guard — same protection as per-symbol Sharpe.
+            if (portfolioStdDev > STDDEV_EPSILON) {
+                portfolioSharpeRatio = portfolioAvg / portfolioStdDev;
+            }
         }
-        // Calculate portfolio-wide weighted average peak/fall PNL
+        // Portfolio-wide weighted average peak/fall PNL. Denominator must include only
+        // symbols that contributed a value — otherwise trade-count-weighted mean is diluted
+        // by symbols without the metric.
         let portfolioAvgPeakPnl = null;
         let portfolioAvgFallPnl = null;
         const validPeak = symbols.filter((s) => s.avgPeakPnl !== null);
         const validFall = symbols.filter((s) => s.avgFallPnl !== null);
-        if (validPeak.length > 0 && portfolioTotalTrades > 0) {
-            portfolioAvgPeakPnl = validPeak.reduce((acc, s) => acc + s.avgPeakPnl * s.totalTrades, 0) / portfolioTotalTrades;
+        const peakTradesTotal = validPeak.reduce((acc, s) => acc + s.totalTrades, 0);
+        const fallTradesTotal = validFall.reduce((acc, s) => acc + s.totalTrades, 0);
+        if (validPeak.length > 0 && peakTradesTotal > 0) {
+            portfolioAvgPeakPnl = validPeak.reduce((acc, s) => acc + s.avgPeakPnl * s.totalTrades, 0) / peakTradesTotal;
         }
-        if (validFall.length > 0 && portfolioTotalTrades > 0) {
-            portfolioAvgFallPnl = validFall.reduce((acc, s) => acc + s.avgFallPnl * s.totalTrades, 0) / portfolioTotalTrades;
+        if (validFall.length > 0 && fallTradesTotal > 0) {
+            portfolioAvgFallPnl = validFall.reduce((acc, s) => acc + s.avgFallPnl * s.totalTrades, 0) / fallTradesTotal;
         }
         // Apply safe math
         if (isUnsafe(portfolioTotalPnl))
@@ -26708,7 +27181,7 @@ class HeatmapStorage {
      * ```
      * # Portfolio Heatmap: {strategyName}
      *
-     * **Total Symbols:** N | **Portfolio PNL:** X% | **Portfolio Sharpe:** Y | **Total Trades:** Z
+     * **Total Symbols:** N | **Portfolio PNL:** X% | **Pooled Sharpe:** Y | **Total Trades:** Z
      *
      * | col1 | col2 | ... |
      * | ---  | ---  | ... |
@@ -26747,18 +27220,21 @@ class HeatmapStorage {
         return [
             `# Portfolio Heatmap: ${strategyName}`,
             "",
-            `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? functoolsKit.str(data.portfolioTotalPnl, "%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? functoolsKit.str(data.portfolioSharpeRatio) : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades} | **Avg Peak PNL:** ${data.portfolioAvgPeakPnl !== null ? functoolsKit.str(data.portfolioAvgPeakPnl, "%") : "N/A"} | **Avg Max Drawdown PNL:** ${data.portfolioAvgFallPnl !== null ? functoolsKit.str(data.portfolioAvgFallPnl, "%") : "N/A"}`,
+            `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? functoolsKit.str(data.portfolioTotalPnl, "%") : "N/A"} | **Pooled Sharpe:** ${data.portfolioSharpeRatio !== null ? functoolsKit.str(data.portfolioSharpeRatio) : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades} | **Avg Peak PNL:** ${data.portfolioAvgPeakPnl !== null ? functoolsKit.str(data.portfolioAvgPeakPnl, "%") : "N/A"} | **Avg Max Drawdown PNL:** ${data.portfolioAvgFallPnl !== null ? functoolsKit.str(data.portfolioAvgFallPnl, "%") : "N/A"}`,
             "",
             table,
             "",
             `*Win Rate: reliable above 200+ signals; below 30 signals a single streak can shift it by 10-20%.*`,
+            `*Pooled Sharpe: Sharpe computed over all trades across symbols treated as one sample. NOT a Markowitz portfolio Sharpe — ignores cross-symbol correlations and capital allocation. N/A unless ≥${MIN_SIGNALS_FOR_RATIOS} pooled trades.*`,
             `*Sharpe Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals per symbol.*`,
-            `*Sortino Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals.*`,
+            `*Sortino Ratio: below 1.0 is poor, 1.0-2.0 is acceptable, above 2.0 is strong. Requires 30+ signals. N/A when no losing trades — Sortino is mathematically undefined (infinite) and we cannot distinguish "truly flawless" from "lucky streak so far".*`,
             `*Certainty Ratio: below 1.0 means average loss exceeds average win. Above 1.5 is considered good.*`,
             `*Profit Factor: below 1.0 means strategy is losing overall. Above 1.5 is considered good.*`,
-            `*Calmar Ratio: below 0.5 is poor, 0.5-1.0 is acceptable, above 1.0 is strong. Based on theoretical yearly returns.*`,
-            `*Recovery Factor: below 1.0 means total profit does not cover max drawdown. Above 3.0 is considered good.*`,
-            `*All metrics require 100+ signals per symbol to be statistically reliable. Time period matters only for Calmar Ratio — it assumes current market conditions hold year-round, which may not reflect reality.*`,
+            `*Calmar Ratio: below 0.5 is poor, 0.5-1.0 is acceptable, above 1.0 is strong. Denominator is compounded equity-curve max drawdown. N/A unless ≥${MIN_SIGNALS_FOR_ANNUALIZATION} signals per symbol and span ≥${MIN_CALENDAR_SPAN_DAYS} days. Capped at ±${MAX_CALMAR_RATIO}.*`,
+            `*Recovery Factor: below 1.0 means total profit does not cover max drawdown. Above 3.0 is considered good. Uses compounded total return as numerator.*`,
+            `*All metrics require 100+ signals per symbol to be statistically reliable. Annualized metrics assume the observed trading frequency persists year-round.*`,
+            `*IMPORTANT: Per-symbol equity curve, Expected Yearly Returns, Calmar, Recovery and Max Drawdown all assume **100% capital allocation per trade** (no sizing, no portfolio fraction). If your strategy risks X% of capital per trade, the realized return / drawdown will be roughly X/100 of the reported figures. The framework does not track portfolio-level sizing, so these metrics represent a theoretical upper bound under full allocation.*`,
+            `*Negative values for Sharpe / Sortino / Calmar / Recovery indicate a losing symbol (avgPnl < 0 or totalPnl < 0). "Higher is better" still applies — closer to zero is less bad, positive is profitable.*`,
         ].join("\n");
     }
     /**
@@ -26953,7 +27429,7 @@ class HeatMarkdownService {
          * console.log(markdown);
          * // # Portfolio Heatmap: my-strategy
          * //
-         * // **Total Symbols:** 5 | **Portfolio PNL:** +45.3% | **Portfolio Sharpe:** 1.85 | **Total Trades:** 120
+         * // **Total Symbols:** 5 | **Portfolio PNL:** +45.3% | **Pooled Sharpe:** 1.85 | **Total Trades:** 120
          * //
          * // | Symbol | Total PNL | Sharpe | Max DD | Trades |
          * // | ---    | ---       | ---    | ---    | ---    |
@@ -53948,7 +54424,7 @@ const REPORT_UTILS_METHOD_NAME_USE_DUMMY = "ReportUtils.useDummy";
 const REPORT_UTILS_METHOD_NAME_USE_JSONL = "ReportUtils.useJsonl";
 const REPORT_UTILS_METHOD_NAME_CLEAR = "ReportUtils.clear";
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$2 = new LoggerService();
+const LOGGER_SERVICE$3 = new LoggerService();
 /**
  * Default configuration that enables all report services.
  * Used when no specific configuration is provided to enable().
@@ -54005,7 +54481,7 @@ class ReportUtils {
          * @returns Cleanup function that unsubscribes from all enabled services
          */
         this.enable = functoolsKit.singleshot(({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, strategy = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET$2) => {
-            LOGGER_SERVICE$2.debug(REPORT_UTILS_METHOD_NAME_ENABLE, {
+            LOGGER_SERVICE$3.debug(REPORT_UTILS_METHOD_NAME_ENABLE, {
                 backtest: bt,
                 breakeven,
                 heat,
@@ -54100,7 +54576,7 @@ class ReportUtils {
          * ```
          */
         this.disable = ({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, schedule = false, walker = false, strategy = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET$2) => {
-            LOGGER_SERVICE$2.debug(REPORT_UTILS_METHOD_NAME_DISABLE, {
+            LOGGER_SERVICE$3.debug(REPORT_UTILS_METHOD_NAME_DISABLE, {
                 backtest: bt,
                 breakeven,
                 heat,
@@ -54180,7 +54656,7 @@ class ReportAdapter extends ReportUtils {
      * @param Ctor - Constructor for report storage adapter
      */
     useReportAdapter(Ctor) {
-        LOGGER_SERVICE$2.info(REPORT_UTILS_METHOD_NAME_USE_REPORT_ADAPTER);
+        LOGGER_SERVICE$3.info(REPORT_UTILS_METHOD_NAME_USE_REPORT_ADAPTER);
         ReportWriter.useReportAdapter(Ctor);
     }
     /**
@@ -54189,7 +54665,7 @@ class ReportAdapter extends ReportUtils {
      * so new storage instances are created with the updated base path.
      */
     clear() {
-        LOGGER_SERVICE$2.log(REPORT_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$3.log(REPORT_UTILS_METHOD_NAME_CLEAR);
         ReportWriter.clear();
     }
     /**
@@ -54197,7 +54673,7 @@ class ReportAdapter extends ReportUtils {
      * All future report writes will be no-ops.
      */
     useDummy() {
-        LOGGER_SERVICE$2.log(REPORT_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$3.log(REPORT_UTILS_METHOD_NAME_USE_DUMMY);
         ReportWriter.useDummy();
     }
     /**
@@ -54205,7 +54681,7 @@ class ReportAdapter extends ReportUtils {
      * All future report writes will use JSONL storage.
      */
     useJsonl() {
-        LOGGER_SERVICE$2.log(REPORT_UTILS_METHOD_NAME_USE_JSONL);
+        LOGGER_SERVICE$3.log(REPORT_UTILS_METHOD_NAME_USE_JSONL);
         ReportWriter.useJsonl();
     }
 }
@@ -54223,7 +54699,7 @@ const MARKDOWN_METHOD_NAME_USE_JSONL = "MarkdownAdapter.useJsonl";
 const MARKDOWN_METHOD_NAME_USE_DUMMY = "MarkdownAdapter.useDummy";
 const MARKDOWN_METHOD_NAME_CLEAR = "MarkdownAdapter.clear";
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$1 = new LoggerService();
+const LOGGER_SERVICE$2 = new LoggerService();
 /**
  * Default configuration that enables all markdown services.
  * Used when no specific configuration is provided to `enable()`.
@@ -54280,7 +54756,7 @@ class MarkdownUtils {
          * @returns Cleanup function that unsubscribes from all enabled services
          */
         this.enable = functoolsKit.singleshot(({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, strategy = false, risk = false, schedule = false, walker = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET$1) => {
-            LOGGER_SERVICE$1.debug(MARKDOWN_METHOD_NAME_ENABLE, {
+            LOGGER_SERVICE$2.debug(MARKDOWN_METHOD_NAME_ENABLE, {
                 backtest: bt,
                 breakeven,
                 heat,
@@ -54377,7 +54853,7 @@ class MarkdownUtils {
          * ```
          */
         this.disable = ({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, strategy = false, schedule = false, walker = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET$1) => {
-            LOGGER_SERVICE$1.debug(MARKDOWN_METHOD_NAME_DISABLE, {
+            LOGGER_SERVICE$2.debug(MARKDOWN_METHOD_NAME_DISABLE, {
                 backtest: bt,
                 breakeven,
                 heat,
@@ -54463,7 +54939,7 @@ class MarkdownUtils {
          * @param config.max_drawdown - Clear max drawdown report data
          */
         this.clear = ({ backtest: bt = false, breakeven = false, heat = false, live = false, partial = false, performance = false, risk = false, strategy = false, schedule = false, walker = false, sync = false, highest_profit = false, max_drawdown = false, } = WILDCARD_TARGET$1) => {
-            LOGGER_SERVICE$1.debug(MARKDOWN_METHOD_NAME_CLEAR, {
+            LOGGER_SERVICE$2.debug(MARKDOWN_METHOD_NAME_CLEAR, {
                 backtest: bt,
                 breakeven,
                 heat,
@@ -54538,7 +55014,7 @@ class MarkdownAdapter extends MarkdownUtils {
      * @param Ctor - Constructor for markdown storage adapter
      */
     useMarkdownAdapter(Ctor) {
-        LOGGER_SERVICE$1.info(MARKDOWN_METHOD_NAME_USE_ADAPTER);
+        LOGGER_SERVICE$2.info(MARKDOWN_METHOD_NAME_USE_ADAPTER);
         return MarkdownWriter.useMarkdownAdapter(Ctor);
     }
     /**
@@ -54547,7 +55023,7 @@ class MarkdownAdapter extends MarkdownUtils {
      * Each dump creates a separate .md file.
      */
     useMd() {
-        LOGGER_SERVICE$1.debug(MARKDOWN_METHOD_NAME_USE_MD);
+        LOGGER_SERVICE$2.debug(MARKDOWN_METHOD_NAME_USE_MD);
         MarkdownWriter.useMd();
     }
     /**
@@ -54556,7 +55032,7 @@ class MarkdownAdapter extends MarkdownUtils {
      * All dumps append to a single .jsonl file per markdown type.
      */
     useJsonl() {
-        LOGGER_SERVICE$1.debug(MARKDOWN_METHOD_NAME_USE_JSONL);
+        LOGGER_SERVICE$2.debug(MARKDOWN_METHOD_NAME_USE_JSONL);
         MarkdownWriter.useJsonl();
     }
     /**
@@ -54564,7 +55040,7 @@ class MarkdownAdapter extends MarkdownUtils {
      * All future markdown writes will be no-ops.
      */
     useDummy() {
-        LOGGER_SERVICE$1.debug(MARKDOWN_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$2.debug(MARKDOWN_METHOD_NAME_USE_DUMMY);
         MarkdownWriter.useDummy();
     }
 }
@@ -63253,6 +63729,503 @@ class IntervalUtils {
  */
 const Interval = new IntervalUtils();
 
+const CRON_METHOD_NAME_REGISTER = "CronUtils.register";
+const CRON_METHOD_NAME_UNREGISTER = "CronUtils.unregister";
+const CRON_METHOD_NAME_CLEAR = "CronUtils.clear";
+const CRON_METHOD_NAME_TICK = "CronUtils._tick";
+const CRON_METHOD_NAME_ENABLE = "CronUtils.enable";
+const CRON_METHOD_NAME_DISABLE = "CronUtils.disable";
+const CRON_METHOD_NAME_DISPOSE = "CronUtils.dispose";
+/**
+ * Local logger instance.
+ *
+ * Created directly rather than resolved from the DI container so that
+ * `CronUtils` has no compile-time dependency on the rest of the framework
+ * being bootstrapped — `Cron` can be imported and used in isolation.
+ */
+const LOGGER_SERVICE$1 = new LoggerService();
+/**
+ * Utility class for registering periodic tasks that fire on candle-interval
+ * boundaries of the virtual time produced by parallel backtests.
+ *
+ * Exported as singleton instance `Cron` for convenient usage.
+ *
+ * Key property — **singleshot coordination across parallel backtests**:
+ * when several `Backtest.background(symbol, ...)` runs hit the same aligned
+ * boundary concurrently, the handler is invoked exactly once. Every parallel
+ * `tick` for that boundary awaits the same in-flight promise and is released
+ * together when the promise settles. After settlement the slot is cleared and
+ * the next boundary produces a fresh promise.
+ *
+ * Typical wiring:
+ *
+ * @example
+ * ```typescript
+ * import { Cron, Backtest } from "backtest-kit";
+ *
+ * Cron.register({
+ *   name: "tg-signal-parser",
+ *   interval: "1h",
+ *   handler: async (symbol, when, backtest) => {
+ *     await parseTelegramSignalsToMongo(when);
+ *   },
+ * });
+ *
+ * // Subscribe Cron to the engine's lifecycle subjects (beforeStart,
+ * // idlePing, activePing, schedulePing) once at startup. After this every
+ * // strategy tick is forwarded into Cron automatically.
+ * Cron.enable();
+ *
+ * for (const symbol of ["BTCUSDT", "ETHUSDT", "SOLUSDT", "BNBUSDT", "TRXUSDT"]) {
+ *   Backtest.background(symbol, { strategyName, exchangeName, frameName });
+ * }
+ *
+ * // On shutdown:
+ * // Cron.disable();
+ * ```
+ */
+class CronUtils {
+    constructor() {
+        /**
+         * Registered entries by `name`.
+         *
+         * Each record carries a monotonically increasing `generation` counter that
+         * is bumped on every `register(entry)` call for the same name. The
+         * generation participates in `firedKey` so writes from a still-in-flight
+         * handler of a previous incarnation cannot poison `_firedOnce` for the
+         * current incarnation — their key has a different generation suffix and
+         * is simply ignored on lookup.
+         */
+        this._entries = new Map();
+        /** Monotonic counter used to mint new entry generations on `register`. */
+        this._generationCounter = 0;
+        /**
+         * In-flight handler slots.
+         *
+         * Slot key shape (always includes the generation suffix `:g${generation}`;
+         * the `:${symbol}` scope is present only in fan-out mode):
+         * - Periodic global: `${name}:${alignedMs}:g${generation}`.
+         * - Periodic fan-out: `${name}:${alignedMs}:${symbol}:g${generation}`.
+         * - Fire-once global: `${name}:once:g${generation}`.
+         * - Fire-once fan-out: `${name}:once:${symbol}:g${generation}`.
+         *
+         * Value is the shared in-flight handler promise. Every parallel `tick` for
+         * the same slot key awaits this exact promise (mutex semantics) and is
+         * released together when it settles. `_inFlight` is owned exclusively by
+         * `_runEntry` — `clear()` does **not** touch it, so the singleshot promise
+         * survives concurrent `clear` calls and continues to coordinate parallel
+         * ticks until it settles.
+         */
+        this._inFlight = new Map();
+        /**
+         * Keys of fire-once entries whose handler has already settled successfully.
+         *
+         * Key shape (always includes the entry generation suffix `:g${generation}`):
+         * - Global fire-once: `${name}:g${generation}`.
+         * - Fan-out fire-once: `${name}:${symbol}:g${generation}` — one entry per
+         *   whitelisted symbol.
+         *
+         * The generation suffix isolates incarnations of the same `name`: writes
+         * landing from a still-in-flight handler of a previous `register()` carry
+         * the old generation and are never matched by the new entry's lookup.
+         * Stale entries are pruned by `_clearFiredOnceFor` on `register`/`unregister`
+         * and wiped by `clear()`.
+         *
+         * Looked up by `_tick` to decide whether to skip; written by `_runEntry`
+         * on successful settle.
+         */
+        this._firedOnce = new Set();
+        /**
+         * Register a periodic cron entry.
+         *
+         * Idempotent on `name`: re-registering the same name replaces the previous
+         * entry (interval/symbols/handler can all change). Re-registration does
+         * **not** clear in-flight promises — entries still resolving complete with
+         * the previous handler.
+         *
+         * @param entry - Entry configuration; see {@link CronEntry}.
+         * @returns Disposer function — call it to unregister the entry.
+         *
+         * @example
+         * ```typescript
+         * const dispose = Cron.register({
+         *   name: "fetch-funding",
+         *   interval: "8h",
+         *   symbols: ["BTCUSDT", "ETHUSDT"],
+         *   handler: async (symbol, when, backtest) => { ... },
+         * });
+         * // Later:
+         * dispose();
+         * ```
+         */
+        this.register = (entry) => {
+            LOGGER_SERVICE$1.info(CRON_METHOD_NAME_REGISTER, {
+                name: entry.name,
+                interval: entry.interval,
+                symbols: entry.symbols,
+            });
+            if (!entry.name) {
+                throw new Error("CronUtils.register requires a non-empty name");
+            }
+            if (entry.name.includes(":")) {
+                throw new Error(`CronUtils.register: name must not contain ':' (got "${entry.name}"). ` +
+                    `':' is reserved as the segment separator in slot keys.`);
+            }
+            if (entry.symbols) {
+                for (const symbol of entry.symbols) {
+                    if (symbol.includes(":")) {
+                        throw new Error(`CronUtils.register: symbols[] entry must not contain ':' (got "${symbol}"). ` +
+                            `':' is reserved as the segment separator in slot keys.`);
+                    }
+                }
+            }
+            this._clearFiredOnceFor(entry.name);
+            const generation = ++this._generationCounter;
+            this._entries.set(entry.name, { entry, generation });
+            return () => this.unregister(entry.name);
+        };
+        /**
+         * Remove a registered entry by name.
+         *
+         * Does not cancel handlers already in flight — those resolve on their own
+         * and clear their slot via `.finally()`.
+         *
+         * @param name - Name passed to `register`.
+         */
+        this.unregister = (name) => {
+            LOGGER_SERVICE$1.info(CRON_METHOD_NAME_UNREGISTER, { name });
+            this._entries.delete(name);
+            this._clearFiredOnceFor(name);
+        };
+        /**
+         * Clear fire-once marks so that fire-once entries can fire again.
+         *
+         * Does **not** touch `_inFlight` — that map holds shared in-flight handler
+         * promises through which parallel `tick`s coordinate. Wiping it mid-flight
+         * would let a new `tick` start a second handler for a boundary that's
+         * already running, breaking the singleshot contract.
+         *
+         * Two modes:
+         * - **Per-symbol** (`symbol` provided): clears only fan-out fire-once
+         *   marks for that symbol — keys of the shape `${name}:${symbol}:g${gen}`.
+         *   Global fire-once marks (`${name}:g${gen}`, no symbol component) are
+         *   left intact, since they are not attributable to a single symbol.
+         *   Useful for re-arming fan-out fire-once entries when a particular
+         *   symbol's run finishes and you want a future re-run to fire again.
+         * - **All** (no argument): wipes every fire-once mark across all entries
+         *   and symbols. Registered entries are not removed — use `unregister`
+         *   (or the disposer returned by `register`) for that.
+         *
+         * **Race with in-flight handlers.** `_firedOnce` is written in
+         * `_runEntry`'s `.finally()`, which can run *after* a concurrent
+         * `clear()` call. In that case the fire-once mark reappears immediately
+         * after being wiped, and the next tick will treat the entry as already
+         * fired. This is consistent with the singleshot promise itself surviving
+         * `clear()` — the handler is allowed to finish — and the entry's
+         * generation suffix in `firedKey` guarantees the stale mark cannot
+         * outlive a subsequent `register()` of the same name. If you need a hard
+         * re-arm, `unregister` + `register` bumps the generation and makes any
+         * late write a no-op.
+         *
+         * @param symbol - Optional symbol filter; if omitted, clears all fire-once
+         *   marks.
+         */
+        this.clear = (symbol) => {
+            LOGGER_SERVICE$1.info(CRON_METHOD_NAME_CLEAR, { symbol });
+            if (!symbol) {
+                this._firedOnce.clear();
+                return;
+            }
+            const symbolSegment = `:${symbol}:`;
+            for (const key of this._firedOnce) {
+                if (key.includes(symbolSegment)) {
+                    this._firedOnce.delete(key);
+                }
+            }
+        };
+        /**
+         * Process a virtual-time tick for `symbol` and fire any due cron entries.
+         *
+         * **Private.** Invoked exclusively by the lifecycle bridge installed in
+         * {@link enable} — `beforeStart` / `idlePing` / `activePing` / `schedulePing`
+         * are funneled here through a shared `singlerun` queue, so calls to
+         * `_tick` are serialised end-to-end. Do not call directly.
+         *
+         * Algorithm (per registered entry):
+         * 0. Base-align the incoming `when` down to the 1-minute boundary (`ts`).
+         *    Lifecycle subjects may emit with sub-second jitter; rounding here
+         *    guarantees that `beforeStart` / `idlePing` / `activePing` /
+         *    `schedulePing` for the same virtual minute all hash to the same
+         *    slot key.
+         * 1. If `entry.symbols` is non-empty and does not include `symbol`, skip.
+         * 2. Decide scope from `entry.symbols`:
+         *    - Empty/undefined → **global** (slot key has no symbol component).
+         *    - Non-empty → **fan-out**, slot key carries `:${symbol}` so each
+         *      whitelisted symbol gets its own slot and handler invocation.
+         * 3. Append the current entry generation suffix `:g${generation}` to both
+         *    slot key and fired-once key. This isolates incarnations of the same
+         *    `name`: a `register()` after an in-flight handler bumps the
+         *    generation, so the late `_firedOnce` write from the old handler can
+         *    never block the new entry.
+         * 4. **Fire-once** (`entry.interval === undefined`):
+         *    - If the entry's fired-once key is already in `_firedOnce`, skip.
+         *    - Slot key: `${name}:once` (+ scope) (+ gen).
+         *    - `aligned` = the 1-minute-aligned `when` from step 0.
+         * 5. **Periodic** (`entry.interval` set):
+         *    - Align `when` further to the entry's interval via {@link alignToInterval}.
+         *    - If `ts !== alignedMs`, the tick is mid-interval — skip.
+         *      (This is the "remainder === 0" boundary check from the spec;
+         *      since `ts` is already on the 1-minute boundary, the check is exact
+         *      for `1m` and consistent for higher intervals.)
+         *    - Slot key: `${name}:${alignedMs}` (+ scope) (+ gen).
+         * 6. Singleshot per slot key: look up the slot in `_inFlight`. If a promise
+         *    already exists, `await` the same promise. Otherwise invoke
+         *    `entry.handler`, store the promise, and `await` it. The slot is
+         *    removed in `.finally()` so the next boundary creates a fresh promise;
+         *    for fire-once entries the fired-once key is also added to
+         *    `_firedOnce` on success so subsequent ticks skip it.
+         *
+         * Errors thrown by `handler` are caught, logged via `console.error`, and
+         * **not** rethrown — a failing handler must not break the per-symbol
+         * tick loop or unblock other parallel backtests with an unhandled
+         * rejection. A failed fire-once handler is **not** marked as fired and
+         * will retry on the next tick.
+         *
+         * Requires active method context and execution context.
+         *
+         * @param symbol - Trading symbol from the current tick.
+         * @param when - Virtual time of the current tick.
+         * @param backtest - `true` for backtest ticks, `false` for live ticks.
+         *   Forwarded as the third argument to `entry.handler`. Only the value
+         *   from the tick that **opens** a given slot is observed by all parallel
+         *   awaiters of that slot.
+         * @throws Error if method or execution context is missing.
+         */
+        this._tick = async (symbol, when, backtest) => {
+            LOGGER_SERVICE$1.debug(CRON_METHOD_NAME_TICK, {
+                symbol,
+                when,
+            });
+            if (!MethodContextService.hasContext()) {
+                throw new Error("CronUtils _tick requires method context");
+            }
+            if (!ExecutionContextService.hasContext()) {
+                throw new Error("CronUtils _tick requires execution context");
+            }
+            const ts = alignToInterval(when, "1m").getTime();
+            const taskList = [];
+            for (const { entry, generation } of this._entries.values()) {
+                if (entry.symbols?.length && !entry.symbols.includes(symbol)) {
+                    continue;
+                }
+                const perSymbol = !!entry.symbols?.length;
+                const scope = perSymbol ? `:${symbol}` : "";
+                const genSuffix = `:g${generation}`;
+                let aligned;
+                let alignedMs;
+                let slotKey;
+                let firedKey;
+                if (entry.interval === undefined) {
+                    const onceKey = `${entry.name}${scope}${genSuffix}`;
+                    if (this._firedOnce.has(onceKey)) {
+                        continue;
+                    }
+                    aligned = alignToInterval(when, "1m");
+                    alignedMs = ts;
+                    slotKey = `${entry.name}:once${scope}${genSuffix}`;
+                    firedKey = onceKey;
+                }
+                else {
+                    aligned = alignToInterval(when, entry.interval);
+                    alignedMs = aligned.getTime();
+                    if (ts !== alignedMs) {
+                        continue;
+                    }
+                    slotKey = `${entry.name}:${alignedMs}${scope}${genSuffix}`;
+                    firedKey = null;
+                }
+                let pending = this._inFlight.get(slotKey);
+                if (!pending) {
+                    pending = this._runEntry(entry, symbol, aligned, alignedMs, slotKey, firedKey, backtest);
+                    this._inFlight.set(slotKey, pending);
+                }
+                taskList.push(pending);
+            }
+            await Promise.all(taskList);
+        };
+        /**
+         * Subscribe `Cron` to the engine's strategy lifecycle subjects so registered
+         * entries fire automatically — no manual wiring of `listenTickBacktest` /
+         * `listenSchedulePing` etc. needed.
+         *
+         * Subjects funneled into {@link _tick}:
+         * - `beforeStartSubject` — first event of every run.
+         * - `idlePingSubject` — every tick when no signal is pending or scheduled.
+         * - `activePingSubject` — every tick while a pending signal is being monitored.
+         * - `schedulePingSubject` — every tick while a scheduled signal is being monitored.
+         *
+         * All four subjects are subscribed to a single `singlerun`-wrapped
+         * handler that builds `_tick(event.symbol, new Date(event.timestamp),
+         * event.backtest)`. `singlerun` merges the four streams into one serial
+         * queue: at most one `_tick` runs at a time, the next waits. This matters
+         * because the engine can emit `beforeStart` and an immediate `idlePing`
+         * on the very same minute, and concurrent `_tick`s on the same
+         * `(symbol, minute)` would otherwise race to open the same `_inFlight`
+         * slot before either commit. Together these four sources cover every
+         * tick the engine processes for every `(symbol, virtual-minute)` pair
+         * regardless of whether the strategy is idle, active, or scheduled.
+         *
+         * `enable` itself is wrapped in `singleshot`, so calling it repeatedly is
+         * a no-op — subsequent calls return the same disposer. The disposer
+         * unsubscribes from every subject and resets the singleshot so a future
+         * `enable()` can re-subscribe cleanly. Equivalent to the
+         * `RecentAdapter.enable` pattern.
+         *
+         * The `.subscribe` callbacks are synchronous wrappers around the
+         * `singlerun`-async handler; `_tick`'s returned promise is awaited inside
+         * `singlerun` to enforce ordering but not bubbled back to the subject.
+         * Errors are caught and logged inside `_runEntry`.
+         *
+         * @returns Cleanup function that unsubscribes from all four subjects and
+         *   resets the singleshot. Idempotent.
+         *
+         * @example
+         * ```typescript
+         * import { Cron } from "backtest-kit";
+         *
+         * Cron.register({ name: "tg-parser", interval: "1h", handler });
+         * Cron.enable(); // wire once at startup
+         * // ... run backtests / live as usual
+         * Cron.disable(); // on shutdown
+         * ```
+         */
+        this.enable = functoolsKit.singleshot(() => {
+            LOGGER_SERVICE$1.info(CRON_METHOD_NAME_ENABLE);
+            const handleTick = functoolsKit.singlerun(async (event) => {
+                return await this._tick(event.symbol, new Date(event.timestamp), event.backtest);
+            });
+            const unBeforeStart = beforeStartSubject.subscribe(handleTick);
+            const unIdlePing = idlePingSubject.subscribe(handleTick);
+            const unActivePing = activePingSubject.subscribe(handleTick);
+            const unSchedulePing = schedulePingSubject.subscribe(handleTick);
+            return functoolsKit.compose(() => unBeforeStart(), () => unIdlePing(), () => unActivePing(), () => unSchedulePing(), () => this.enable.clear());
+        });
+        /**
+         * Tear down the lifecycle subscriptions installed by {@link enable}.
+         *
+         * Safe to call multiple times and safe to call before `enable()` — both
+         * are no-ops. Does **not** unregister entries, does **not** touch
+         * `_inFlight`, and does **not** wipe `_firedOnce` (use `unregister` or
+         * `clear()` for those).
+         */
+        this.disable = () => {
+            LOGGER_SERVICE$1.info(CRON_METHOD_NAME_DISABLE);
+            if (this.enable.hasValue()) {
+                const lastSubscription = this.enable();
+                lastSubscription();
+            }
+        };
+        /**
+         * Hard-reset the entire `Cron` state.
+         *
+         * Performs in order:
+         * 1. {@link disable} — tears down lifecycle subscriptions and resets the
+         *    `enable` singleshot so a future `enable()` re-subscribes cleanly.
+         * 2. Wipes `_entries` — every {@link register}'ed entry is forgotten.
+         *    Disposers returned by previous `register()` calls become no-ops
+         *    (their `unregister(name)` will not find anything to remove).
+         * 3. Wipes `_firedOnce` — all fire-once marks are dropped, so any future
+         *    re-registration of the same `name` fires again on the next matching
+         *    tick.
+         * 4. Does **not** touch `_inFlight` — in-flight handlers continue to
+         *    settle in the background and clear their own slots via `.finally()`.
+         *    Their final `_firedOnce.add(firedKey)` writes carry old-generation
+         *    keys and are harmless (lookup uses the post-dispose generation).
+         *
+         * Use from a CLI/session teardown when you want to throw away every
+         * registration along with the lifecycle wiring — e.g. between two
+         * independent runner scopes. For "just snap the subscriptions but keep
+         * registrations" use {@link disable} instead; for "just re-arm fire-once
+         * marks" use {@link clear}.
+         *
+         * Idempotent. Safe to call multiple times and safe to call before
+         * `enable()` / without any registrations.
+         */
+        this.dispose = () => {
+            LOGGER_SERVICE$1.info(CRON_METHOD_NAME_DISPOSE);
+            this.disable();
+            this._entries.clear();
+            this._firedOnce.clear();
+        };
+    }
+    /**
+     * Garbage-collect every `_firedOnce` key that belongs to the entry `name`
+     * (any generation, global or fan-out).
+     *
+     * Called from `register`/`unregister` to free memory; **not** required
+     * for correctness — the generation suffix already isolates re-registrations,
+     * so leftover keys from old generations can never block a new entry.
+     * They just sit unused until they are GC'd here or wiped by `clear()`.
+     */
+    _clearFiredOnceFor(name) {
+        if (!name) {
+            return;
+        }
+        const prefix = `${name}:`;
+        for (const key of this._firedOnce) {
+            if (key === name || key.startsWith(prefix)) {
+                this._firedOnce.delete(key);
+            }
+        }
+    }
+    /**
+     * Build the singleshot promise for a single in-flight slot.
+     *
+     * Invokes `entry.handler(symbol, aligned, backtest)`, swallows and logs
+     * any error via `console.error`, and clears the `_inFlight` slot
+     * in `.finally()` so the next boundary produces a fresh promise. For
+     * fire-once entries `firedKey` is added to `_firedOnce` on success so
+     * subsequent ticks skip it.
+     *
+     * @param firedKey - Key to add to `_firedOnce` on success, or `null` for
+     *   periodic entries (which never populate `_firedOnce`).
+     * @param backtest - Value forwarded as the third handler argument; the
+     *   "winner" tick's flag is what all parallel awaiters of this slot see.
+     */
+    async _runEntry(entry, symbol, aligned, alignedMs, slotKey, firedKey, backtest) {
+        let failed = false;
+        try {
+            await entry.handler(symbol, aligned, backtest);
+        }
+        catch (err) {
+            failed = true;
+            console.error(`${CRON_METHOD_NAME_TICK} entry "${entry.name}" failed`, { symbol, alignedMs, err });
+        }
+        finally {
+            this._inFlight.delete(slotKey);
+            if (!failed && firedKey !== null) {
+                this._firedOnce.add(firedKey);
+            }
+        }
+    }
+}
+/**
+ * Singleton instance of {@link CronUtils} for registering periodic tasks
+ * coordinated across parallel `Backtest.background` runs.
+ *
+ * @example
+ * ```typescript
+ * import { Cron } from "backtest-kit";
+ *
+ * Cron.register({
+ *   name: "tg-parser",
+ *   interval: "1h",
+ *   handler: async (symbol, when, backtest) => { ... },
+ * });
+ * ```
+ */
+const Cron = new CronUtils();
+
 const BREAKEVEN_METHOD_NAME_GET_DATA = "BreakevenUtils.getData";
 const BREAKEVEN_METHOD_NAME_GET_REPORT = "BreakevenUtils.getReport";
 const BREAKEVEN_METHOD_NAME_DUMP = "BreakevenUtils.dump";
@@ -64335,7 +65308,7 @@ const validateSignal = (signal, currentPrice) => {
         }
     }
     if (errors.length > 0) {
-        console.error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        console.error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
         return false;
     }
     try {
@@ -64408,7 +65381,7 @@ const validateSignal = (signal, currentPrice) => {
         }
     }
     if (errors.length > 0) {
-        console.error(`Invalid signal for ${signal.position} position:\n${errors.join("\n")}`);
+        console.error(`Invalid signal for ${signal.position} position (${signal.symbol || "empty symbol"}):\n${errors.join("\n")}`);
     }
     return !errors.length;
 };
@@ -64420,6 +65393,7 @@ exports.Broker = Broker;
 exports.BrokerBase = BrokerBase;
 exports.Cache = Cache;
 exports.Constant = Constant;
+exports.Cron = Cron;
 exports.Dump = Dump;
 exports.Exchange = Exchange;
 exports.ExecutionContextService = ExecutionContextService;
@@ -64694,6 +65668,7 @@ exports.shutdown = shutdown;
 exports.slPercentShiftToPrice = slPercentShiftToPrice;
 exports.slPriceToPercentShift = slPriceToPercentShift;
 exports.stopStrategy = stopStrategy;
+exports.toPlainString = toPlainString;
 exports.toProfitLossDto = toProfitLossDto;
 exports.tpPercentShiftToPrice = tpPercentShiftToPrice;
 exports.tpPriceToPercentShift = tpPriceToPercentShift;