backtest-kit 9.8.5 → 10.2.0

package/build/index.mjs

@@ -942,7 +942,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
@@ -1065,7 +1065,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,
     });
@@ -1123,7 +1123,7 @@ class PersistBase {
         this.entityName = entityName;
         this.baseDir = baseDir;
         this[_a$3] = 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,
         });
@@ -1139,14 +1139,14 @@ class PersistBase {
         return 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,
         });
@@ -1163,7 +1163,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,
         });
@@ -1180,7 +1180,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,
         });
@@ -1202,7 +1202,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 {
@@ -1347,7 +1347,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);
@@ -1365,7 +1365,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);
@@ -1380,7 +1380,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();
     }
@@ -1389,21 +1389,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);
     }
 }
@@ -1543,7 +1543,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);
@@ -1561,7 +1561,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);
@@ -1576,7 +1576,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();
     }
@@ -1585,21 +1585,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);
     }
 }
@@ -1738,7 +1738,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);
@@ -1756,7 +1756,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);
@@ -1771,7 +1771,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();
     }
@@ -1780,21 +1780,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);
     }
 }
@@ -1939,7 +1939,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);
@@ -1959,7 +1959,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);
@@ -1974,7 +1974,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();
     }
@@ -1983,21 +1983,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);
     }
 }
@@ -2162,7 +2162,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);
@@ -2182,7 +2182,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);
@@ -2197,7 +2197,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();
     }
@@ -2206,21 +2206,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);
     }
 }
@@ -2311,7 +2311,7 @@ class PersistCandleInstance {
                     error: errorData(error),
                     message: getErrorMessage(error),
                 };
-                LOGGER_SERVICE$8.warn(message, payload);
+                LOGGER_SERVICE$9.warn(message, payload);
                 console.warn(message, payload);
                 errorEmitter.next(error);
                 return null;
@@ -2333,7 +2333,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,
@@ -2410,7 +2410,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,
@@ -2434,7 +2434,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,
@@ -2454,7 +2454,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();
     }
@@ -2463,21 +2463,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);
     }
 }
@@ -2615,7 +2615,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);
@@ -2631,7 +2631,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);
@@ -2646,7 +2646,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();
     }
@@ -2655,21 +2655,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);
     }
 }
@@ -2796,7 +2796,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);
@@ -2812,7 +2812,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);
@@ -2827,7 +2827,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();
     }
@@ -2837,21 +2837,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);
     }
 }
@@ -2975,7 +2975,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);
@@ -2989,7 +2989,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);
@@ -3014,7 +3014,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;
     }
@@ -3023,21 +3023,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);
     }
 }
@@ -3199,7 +3199,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);
@@ -3215,7 +3215,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);
@@ -3230,7 +3230,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);
@@ -3244,7 +3244,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();
     }
@@ -3256,7 +3256,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);
@@ -3267,21 +3267,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);
     }
 }
@@ -3440,7 +3440,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);
@@ -3456,7 +3456,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);
@@ -3471,7 +3471,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);
@@ -3485,7 +3485,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();
     }
@@ -3497,7 +3497,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);
@@ -3508,21 +3508,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);
     }
 }
@@ -3728,7 +3728,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);
@@ -3745,7 +3745,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);
@@ -3764,7 +3764,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);
@@ -3781,7 +3781,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);
@@ -3793,7 +3793,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();
         };
         /**
@@ -3804,7 +3804,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);
         };
@@ -3816,7 +3816,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();
     }
@@ -3830,7 +3830,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);
@@ -3841,14 +3841,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);
     }
 }
@@ -3997,7 +3997,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);
@@ -4018,7 +4018,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);
@@ -4051,7 +4051,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();
     }
@@ -4060,21 +4060,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);
     }
 }
@@ -4209,7 +4209,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);
@@ -4224,7 +4224,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);
@@ -4242,7 +4242,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);
@@ -4253,14 +4253,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);
         };
         /**
@@ -4268,7 +4268,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();
         };
         /**
@@ -4279,7 +4279,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);
         };
@@ -4291,7 +4291,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();
     }
@@ -4431,7 +4431,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);
@@ -4447,7 +4447,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);
@@ -4466,7 +4466,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);
@@ -4477,14 +4477,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);
         };
         /**
@@ -4492,7 +4492,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();
         };
         /**
@@ -4504,7 +4504,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);
         };
@@ -4516,7 +4516,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();
     }
@@ -4638,7 +4638,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`.
  *
@@ -4692,7 +4692,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);
@@ -4706,7 +4706,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);
@@ -4718,7 +4718,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());
         };
     }
@@ -4747,7 +4747,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.
@@ -4796,7 +4796,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) {
@@ -4812,7 +4812,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) {
@@ -4837,7 +4837,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) {
@@ -6347,7 +6347,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")}`);
     }
 };
 
@@ -6400,7 +6400,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);
     // ЗАЩИТА ОТ МОМЕНТАЛЬНОГО ЗАКРЫТИЯ: проверяем что позиция не закроется сразу после открытия
@@ -6448,7 +6448,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")}`);
     }
 };
 
@@ -6501,7 +6501,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 сигналов
@@ -6547,7 +6547,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")}`);
     }
 };
 
@@ -6994,6 +6994,13 @@ const GET_SIGNAL_FN = 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;
     }
@@ -7037,6 +7044,9 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
             }
             // Валидируем сигнал перед возвратом
             validatePendingSignal(signalRow, currentPrice);
+            if (signal.id) {
+                self._lastPendingId = signal.id;
+            }
             return signalRow;
         }
         // ОЖИДАНИЕ АКТИВАЦИИ: создаем scheduled signal (risk check при активации)
@@ -7063,6 +7073,9 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
         };
         // Валидируем сигнал перед возвратом
         validateScheduledSignal(scheduledSignalRow, currentPrice);
+        if (signal.id) {
+            self._lastPendingId = signal.id;
+        }
         return scheduledSignalRow;
     }
     const signalRow = {
@@ -7090,6 +7103,9 @@ const GET_SIGNAL_FN = trycatch(async (self) => {
     }
     // Валидируем сигнал перед возвратом
     validatePendingSignal(signalRow, currentPrice);
+    if (signal.id) {
+        self._lastPendingId = signal.id;
+    }
     return signalRow;
 }, {
     defaultValue: null,
@@ -7119,6 +7135,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) {
@@ -9259,6 +9282,7 @@ class ClientStrategy {
         this._isStopped = false;
         this._pendingSignal = null;
         this._lastSignalTimestamp = null;
+        this._lastPendingId = null;
         this._scheduledSignal = null;
         this._cancelledSignal = null;
         this._closedSignal = null;
@@ -12048,7 +12072,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.
  *
@@ -12104,7 +12128,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)) {
@@ -12134,7 +12158,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)) {
@@ -12158,7 +12182,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,
         });
@@ -12175,7 +12199,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,
         });
@@ -14968,7 +14992,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.
  */
@@ -14983,7 +15007,7 @@ const CALL_INIT_FN = trycatch(async (self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15003,7 +15027,7 @@ const CALL_SIGNAL_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: 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_LIVE_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: 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_BACKTEST_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15071,7 +15095,7 @@ const CALL_BREAKEVEN_AVAILABLE_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15099,7 +15123,7 @@ const CALL_PARTIAL_PROFIT_AVAILABLE_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15127,7 +15151,7 @@ const CALL_PARTIAL_LOSS_AVAILABLE_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15155,7 +15179,7 @@ const CALL_PING_SCHEDULED_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15183,7 +15207,7 @@ const CALL_PING_IDLE_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -15211,7 +15235,7 @@ const CALL_PING_ACTIVE_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: 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_RISK_REJECTION_FN = trycatch(async (event, self) => {
             error: errorData(error),
             message: 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_DISPOSE_FN = trycatch(async (self) => {
             error: errorData(error),
             message: getErrorMessage(error),
         };
-        LOGGER_SERVICE$4.warn(message, payload);
+        LOGGER_SERVICE$5.warn(message, payload);
         console.warn(message, payload);
         errorEmitter.next(error);
     },
@@ -23115,7 +23139,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. */
@@ -23196,7 +23220,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,
         });
@@ -23276,7 +23300,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,
         });
@@ -23341,7 +23365,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;
     }
     /**
@@ -23355,7 +23379,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,
         });
@@ -23369,7 +23393,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);
     }
     /**
@@ -23377,7 +23401,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);
     }
     /**
@@ -23386,7 +23410,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();
     }
     /**
@@ -23394,7 +23418,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);
     }
 }
@@ -23455,7 +23479,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,
         });
@@ -23469,7 +23493,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,
         });
@@ -23488,7 +23512,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,
         });
@@ -23585,7 +23609,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,
             });
@@ -23602,7 +23626,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;
     }
     /**
@@ -23611,7 +23635,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();
     }
     /**
@@ -23619,7 +23643,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);
     }
     /**
@@ -23627,7 +23651,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);
     }
 }
@@ -23682,7 +23706,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;
     }
@@ -23694,6 +23718,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.
@@ -23747,65 +23790,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,
         };
     }
     /**
@@ -23847,24 +24015,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");
     }
     /**
@@ -24176,7 +24346,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;
     }
@@ -24188,6 +24358,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).
@@ -24471,84 +24660,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,
         };
     }
     /**
@@ -24596,18 +24891,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");
     }
     /**
@@ -24986,7 +25283,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",
@@ -25022,7 +25321,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",
@@ -25078,19 +25378,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;
-        // Calculate average activation time for opened signals
-        const avgActivationTime = totalOpened > 0
-            ? openedEvents.reduce((sum, e) => sum + (e.duration || 0), 0) /
-                totalOpened
+        // 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;
+        const avgActivationTime = openedDurations.length > 0
+            ? openedDurations.reduce((sum, d) => sum + d, 0) / openedDurations.length
             : null;
         return {
             eventList: this._eventList,
@@ -25137,13 +25451,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");
     }
     /**
@@ -25448,13 +25764,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.
@@ -25510,10 +25850,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++) {
@@ -25586,9 +25928,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 [
@@ -26357,6 +26703,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.
@@ -26398,7 +26763,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
@@ -26414,10 +26779,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;
@@ -26429,36 +26796,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;
@@ -26469,7 +26847,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;
             }
         }
@@ -26509,45 +26889,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;
         }
-        // Calculate average peak and fall PNL
+        else if (totalTrades > 0 && avgWin === null && avgLoss !== null) {
+            expectancy = (lossCount / totalTrades) * avgLoss;
+        }
+        // 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))
@@ -26612,12 +27057,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 = [];
@@ -26636,31 +27087,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))
@@ -26688,7 +27161,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 | ... |
      * | ---  | ---  | ... |
@@ -26727,18 +27200,21 @@ class HeatmapStorage {
         return [
             `# Portfolio Heatmap: ${strategyName}`,
             "",
-            `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? str(data.portfolioTotalPnl, "%") : "N/A"} | **Portfolio Sharpe:** ${data.portfolioSharpeRatio !== null ? str(data.portfolioSharpeRatio) : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades} | **Avg Peak PNL:** ${data.portfolioAvgPeakPnl !== null ? str(data.portfolioAvgPeakPnl, "%") : "N/A"} | **Avg Max Drawdown PNL:** ${data.portfolioAvgFallPnl !== null ? str(data.portfolioAvgFallPnl, "%") : "N/A"}`,
+            `**Total Symbols:** ${data.totalSymbols} | **Portfolio PNL:** ${data.portfolioTotalPnl !== null ? str(data.portfolioTotalPnl, "%") : "N/A"} | **Pooled Sharpe:** ${data.portfolioSharpeRatio !== null ? str(data.portfolioSharpeRatio) : "N/A"} | **Total Trades:** ${data.portfolioTotalTrades} | **Avg Peak PNL:** ${data.portfolioAvgPeakPnl !== null ? str(data.portfolioAvgPeakPnl, "%") : "N/A"} | **Avg Max Drawdown PNL:** ${data.portfolioAvgFallPnl !== null ? 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");
     }
     /**
@@ -26933,7 +27409,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 |
          * // | ---    | ---       | ---    | ---    | ---    |
@@ -53928,7 +54404,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().
@@ -53985,7 +54461,7 @@ class ReportUtils {
          * @returns Cleanup function that unsubscribes from all enabled services
          */
         this.enable = 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,
@@ -54080,7 +54556,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,
@@ -54160,7 +54636,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);
     }
     /**
@@ -54169,7 +54645,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();
     }
     /**
@@ -54177,7 +54653,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();
     }
     /**
@@ -54185,7 +54661,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();
     }
 }
@@ -54203,7 +54679,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()`.
@@ -54260,7 +54736,7 @@ class MarkdownUtils {
          * @returns Cleanup function that unsubscribes from all enabled services
          */
         this.enable = 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,
@@ -54357,7 +54833,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,
@@ -54443,7 +54919,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,
@@ -54518,7 +54994,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);
     }
     /**
@@ -54527,7 +55003,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();
     }
     /**
@@ -54536,7 +55012,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();
     }
     /**
@@ -54544,7 +55020,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();
     }
 }
@@ -63233,6 +63709,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 = singleshot(() => {
+            LOGGER_SERVICE$1.info(CRON_METHOD_NAME_ENABLE);
+            const handleTick = 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 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";
@@ -64315,7 +65288,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 {
@@ -64388,9 +65361,9 @@ 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;
 };
 
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, beginContext, beginTime, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenAfterEnd, listenAfterEndOnce, listenBacktestProgress, listenBeforeStart, listenBeforeStartOnce, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Cron, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Lookup, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, beginContext, beginTime, cacheCandles, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, intervalStepMs, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenAfterEnd, listenAfterEndOnce, listenBacktestProgress, listenBeforeStart, listenBeforeStartOnce, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toPlainString, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, waitForReady, warmCandles, writeMemory };