backtest-kit 9.8.1 → 9.8.3

package/build/index.cjs

@@ -574,6 +574,22 @@ const GLOBAL_CONFIG = {
      * Default: true (mutex locking enabled for candle fetching)
      */
     CC_ENABLE_CANDLE_FETCH_MUTEX: true,
+    /**
+     * Enables cooperative interleaving of concurrently running backtests after each candle fetch.
+     *
+     * Mechanism (implemented in `Candle.spinLock`):
+     * - After `getNextCandles` resolves, the current backtest awaits
+     *   `Promise.race([_spin.toPromise(), sleep(50)])`, where `_spin` is emitted whenever
+     *   another caller acquires the candle-fetch mutex.
+     * - This hands the event loop to a peer backtest waiting on the same mutex, so multiple
+     *   parallel `Backtest.run` / `Walker` workloads progress in round-robin fashion instead
+     *   of one monopolizing the event loop until completion.
+     * - The spin is skipped entirely when `Lookup.isParallel` is `false` (single active workload —
+     *   no peer to yield to) or when `CC_ENABLE_CANDLE_FETCH_MUTEX` is disabled.
+     *
+     * Default: true (parallel backtests are interleaved on each candle fetch boundary)
+     */
+    CC_ENABLE_BACKTEST_PARALLEL_SPIN: true,
     /**
      * Enables DCA (Dollar-Cost Averaging) logic even if antirecord is not broken.
      * Allows to commitAverageBuy if currentPrice is not the lowest price since entry, but still lower than priceOpen.
@@ -792,11 +808,23 @@ const maxDrawdownSubject = new functoolsKit.Subject();
  * Emits when a strategy calls commitSignalInfo() to broadcast a custom annotation.
  */
 const signalNotifySubject = new functoolsKit.Subject();
+/**
+ * Before start emitter for strategy initialization events.
+ * Emits when the engine is about to start a new strategy execution.
+ */
+const beforeStartSubject = new functoolsKit.Subject();
+/**
+ * After end emitter for strategy completion events.
+ * Emits when the engine has completed processing a signal.
+ */
+const afterEndSubject = new functoolsKit.Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
     activePingSubject: activePingSubject,
+    afterEndSubject: afterEndSubject,
     backtestScheduleOpenSubject: backtestScheduleOpenSubject,
+    beforeStartSubject: beforeStartSubject,
     breakevenSubject: breakevenSubject,
     doneBacktestSubject: doneBacktestSubject,
     doneLiveSubject: doneLiveSubject,
@@ -934,7 +962,7 @@ async function writeFileAtomic(file, data, options = {}) {
 
 var _a$3;
 /** Logger service injected as DI singleton */
-const LOGGER_SERVICE$7 = new LoggerService();
+const LOGGER_SERVICE$8 = 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
@@ -1057,7 +1085,7 @@ const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
 const BASE_UNLINK_RETRY_COUNT = 5;
 const BASE_UNLINK_RETRY_DELAY = 1000;
 const BASE_WAIT_FOR_INIT_FN = async (self) => {
-    LOGGER_SERVICE$7.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
+    LOGGER_SERVICE$8.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
         entityName: self.entityName,
         directory: self._directory,
     });
@@ -1115,7 +1143,7 @@ class PersistBase {
         this.entityName = entityName;
         this.baseDir = baseDir;
         this[_a$3] = functoolsKit.singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
-        LOGGER_SERVICE$7.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
+        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
             entityName: this.entityName,
             baseDir,
         });
@@ -1131,14 +1159,14 @@ class PersistBase {
         return path.join(this.baseDir, this.entityName, `${entityId}.json`);
     }
     async waitForInit(initial) {
-        LOGGER_SERVICE$7.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
+        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
             entityName: this.entityName,
             initial,
         });
         await this[BASE_WAIT_FOR_INIT_SYMBOL]();
     }
     async readValue(entityId) {
-        LOGGER_SERVICE$7.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
+        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -1155,7 +1183,7 @@ class PersistBase {
         }
     }
     async hasValue(entityId) {
-        LOGGER_SERVICE$7.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
+        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -1172,7 +1200,7 @@ class PersistBase {
         }
     }
     async writeValue(entityId, entity) {
-        LOGGER_SERVICE$7.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
+        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
             entityName: this.entityName,
             entityId,
         });
@@ -1194,7 +1222,7 @@ class PersistBase {
      * @throws Error if reading fails
      */
     async *keys() {
-        LOGGER_SERVICE$7.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
+        LOGGER_SERVICE$8.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
             entityName: this.entityName,
         });
         try {
@@ -1339,7 +1367,7 @@ class PersistSignalUtils {
          * @returns Promise resolving to signal or null if none persisted
          */
         this.readSignalData = async (symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$7.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.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);
@@ -1357,7 +1385,7 @@ class PersistSignalUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeSignalData = async (signalRow, symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$7.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.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);
@@ -1372,7 +1400,7 @@ class PersistSignalUtils {
      * @param Ctor - Custom IPersistSignalInstance constructor
      */
     usePersistSignalAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
         this.PersistSignalInstanceCtor = Ctor;
         this.getStorage.clear();
     }
@@ -1381,21 +1409,21 @@ class PersistSignalUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
      * Switches to the default file-based PersistSignalInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistSignalAdapter(PersistSignalInstance);
     }
     /**
      * Switches to PersistSignalDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistSignalAdapter(PersistSignalDummyInstance);
     }
 }
@@ -1535,7 +1563,7 @@ class PersistRiskUtils {
          * @returns Promise resolving to position entries (empty array if none)
          */
         this.readPositionData = async (riskName, exchangeName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
             const key = `${riskName}:${exchangeName}`;
             const isInitial = !this.getRiskStorage.has(key);
             const instance = this.getRiskStorage(riskName, exchangeName);
@@ -1553,7 +1581,7 @@ class PersistRiskUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writePositionData = async (riskRow, riskName, exchangeName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${riskName}:${exchangeName}`;
             const isInitial = !this.getRiskStorage.has(key);
             const instance = this.getRiskStorage(riskName, exchangeName);
@@ -1568,7 +1596,7 @@ class PersistRiskUtils {
      * @param Ctor - Custom IPersistRiskInstance constructor
      */
     usePersistRiskAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
         this.PersistRiskInstanceCtor = Ctor;
         this.getRiskStorage.clear();
     }
@@ -1577,21 +1605,21 @@ class PersistRiskUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_RISK_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_RISK_UTILS_METHOD_NAME_CLEAR);
         this.getRiskStorage.clear();
     }
     /**
      * Switches to the default file-based PersistRiskInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistRiskAdapter(PersistRiskInstance);
     }
     /**
      * Switches to PersistRiskDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistRiskAdapter(PersistRiskDummyInstance);
     }
 }
@@ -1730,7 +1758,7 @@ class PersistScheduleUtils {
          * @returns Promise resolving to scheduled signal or null if none persisted
          */
         this.readScheduleData = async (symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$7.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.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);
@@ -1748,7 +1776,7 @@ class PersistScheduleUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeScheduleData = async (scheduledSignalRow, symbol, strategyName, exchangeName) => {
-            LOGGER_SERVICE$7.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.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);
@@ -1763,7 +1791,7 @@ class PersistScheduleUtils {
      * @param Ctor - Custom IPersistScheduleInstance constructor
      */
     usePersistScheduleAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
         this.PersistScheduleInstanceCtor = Ctor;
         this.getScheduleStorage.clear();
     }
@@ -1772,21 +1800,21 @@ class PersistScheduleUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_CLEAR);
         this.getScheduleStorage.clear();
     }
     /**
      * Switches to the default file-based PersistScheduleInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistScheduleAdapter(PersistScheduleInstance);
     }
     /**
      * Switches to PersistScheduleDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistScheduleAdapter(PersistScheduleDummyInstance);
     }
 }
@@ -1931,7 +1959,7 @@ class PersistPartialUtils {
          * @returns Promise resolving to partial data record (empty object if none)
          */
         this.readPartialData = async (symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.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);
@@ -1951,7 +1979,7 @@ class PersistPartialUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writePartialData = async (partialData, symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.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);
@@ -1966,7 +1994,7 @@ class PersistPartialUtils {
      * @param Ctor - Custom IPersistPartialInstance constructor
      */
     usePersistPartialAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
         this.PersistPartialInstanceCtor = Ctor;
         this.getPartialStorage.clear();
     }
@@ -1975,21 +2003,21 @@ class PersistPartialUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_CLEAR);
         this.getPartialStorage.clear();
     }
     /**
      * Switches to the default file-based PersistPartialInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistPartialAdapter(PersistPartialInstance);
     }
     /**
      * Switches to PersistPartialDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistPartialAdapter(PersistPartialDummyInstance);
     }
 }
@@ -2154,7 +2182,7 @@ class PersistBreakevenUtils {
          * @returns Promise resolving to breakeven data record (empty object if none)
          */
         this.readBreakevenData = async (symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.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);
@@ -2174,7 +2202,7 @@ class PersistBreakevenUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeBreakevenData = async (breakevenData, symbol, strategyName, signalId, exchangeName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.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);
@@ -2189,7 +2217,7 @@ class PersistBreakevenUtils {
      * @param Ctor - Custom IPersistBreakevenInstance constructor
      */
     usePersistBreakevenAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
         this.PersistBreakevenInstanceCtor = Ctor;
         this.getBreakevenStorage.clear();
     }
@@ -2198,21 +2226,21 @@ class PersistBreakevenUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_CLEAR);
         this.getBreakevenStorage.clear();
     }
     /**
      * Switches to the default file-based PersistBreakevenInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistBreakevenAdapter(PersistBreakevenInstance);
     }
     /**
      * Switches to PersistBreakevenDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistBreakevenAdapter(PersistBreakevenDummyInstance);
     }
 }
@@ -2303,7 +2331,7 @@ class PersistCandleInstance {
                     error: functoolsKit.errorData(error),
                     message: functoolsKit.getErrorMessage(error),
                 };
-                LOGGER_SERVICE$7.warn(message, payload);
+                LOGGER_SERVICE$8.warn(message, payload);
                 console.warn(message, payload);
                 errorEmitter.next(error);
                 return null;
@@ -2325,7 +2353,7 @@ class PersistCandleInstance {
         for (const candle of candles) {
             const candleCloseTime = candle.timestamp + stepMs;
             if (candleCloseTime > now) {
-                LOGGER_SERVICE$7.debug("PersistCandleInstance.writeCandlesData: skipping incomplete candle", {
+                LOGGER_SERVICE$8.debug("PersistCandleInstance.writeCandlesData: skipping incomplete candle", {
                     symbol: this.symbol,
                     interval: this.interval,
                     exchangeName: this.exchangeName,
@@ -2402,7 +2430,7 @@ class PersistCandleUtils {
          * @returns Promise resolving to candles in order, or null on cache miss
          */
         this.readCandlesData = async (symbol, interval, exchangeName, limit, sinceTimestamp, untilTimestamp) => {
-            LOGGER_SERVICE$7.info("PersistCandleUtils.readCandlesData", {
+            LOGGER_SERVICE$8.info("PersistCandleUtils.readCandlesData", {
                 symbol,
                 interval,
                 exchangeName,
@@ -2426,7 +2454,7 @@ class PersistCandleUtils {
          * @returns Promise that resolves when all writes are complete
          */
         this.writeCandlesData = async (candles, symbol, interval, exchangeName) => {
-            LOGGER_SERVICE$7.info("PersistCandleUtils.writeCandlesData", {
+            LOGGER_SERVICE$8.info("PersistCandleUtils.writeCandlesData", {
                 symbol,
                 interval,
                 exchangeName,
@@ -2446,7 +2474,7 @@ class PersistCandleUtils {
      * @param Ctor - Custom IPersistCandleInstance constructor
      */
     usePersistCandleAdapter(Ctor) {
-        LOGGER_SERVICE$7.info("PersistCandleUtils.usePersistCandleAdapter");
+        LOGGER_SERVICE$8.info("PersistCandleUtils.usePersistCandleAdapter");
         this.PersistCandleInstanceCtor = Ctor;
         this.getCandlesStorage.clear();
     }
@@ -2455,21 +2483,21 @@ class PersistCandleUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_CANDLE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_CANDLE_UTILS_METHOD_NAME_CLEAR);
         this.getCandlesStorage.clear();
     }
     /**
      * Switches to the default file-based PersistCandleInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log("PersistCandleUtils.useJson");
+        LOGGER_SERVICE$8.log("PersistCandleUtils.useJson");
         this.usePersistCandleAdapter(PersistCandleInstance);
     }
     /**
      * Switches to PersistCandleDummyInstance (always returns null on read, discards writes).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log("PersistCandleUtils.useDummy");
+        LOGGER_SERVICE$8.log("PersistCandleUtils.useDummy");
         this.usePersistCandleAdapter(PersistCandleDummyInstance);
     }
 }
@@ -2607,7 +2635,7 @@ class PersistStorageUtils {
          * @returns Promise resolving to array of signal entries
          */
         this.readStorageData = async (backtest) => {
-            LOGGER_SERVICE$7.info(PERSIST_STORAGE_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_STORAGE_UTILS_METHOD_NAME_READ_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(backtest);
@@ -2623,7 +2651,7 @@ class PersistStorageUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeStorageData = async (signalData, backtest) => {
-            LOGGER_SERVICE$7.info(PERSIST_STORAGE_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_STORAGE_UTILS_METHOD_NAME_WRITE_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getStorage.has(key);
             const instance = this.getStorage(backtest);
@@ -2638,7 +2666,7 @@ class PersistStorageUtils {
      * @param Ctor - Custom IPersistStorageInstance constructor
      */
     usePersistStorageAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_PERSIST_STORAGE_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_PERSIST_STORAGE_ADAPTER);
         this.PersistStorageInstanceCtor = Ctor;
         this.getStorage.clear();
     }
@@ -2647,21 +2675,21 @@ class PersistStorageUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_STORAGE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_STORAGE_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
      * Switches to the default file-based PersistStorageInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistStorageAdapter(PersistStorageInstance);
     }
     /**
      * Switches to PersistStorageDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistStorageAdapter(PersistStorageDummyInstance);
     }
 }
@@ -2788,7 +2816,7 @@ class PersistNotificationUtils {
          * @returns Promise resolving to array of notification entries
          */
         this.readNotificationData = async (backtest) => {
-            LOGGER_SERVICE$7.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_READ_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getNotificationStorage.has(key);
             const instance = this.getNotificationStorage(backtest);
@@ -2804,7 +2832,7 @@ class PersistNotificationUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeNotificationData = async (notificationData, backtest) => {
-            LOGGER_SERVICE$7.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_WRITE_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getNotificationStorage.has(key);
             const instance = this.getNotificationStorage(backtest);
@@ -2819,7 +2847,7 @@ class PersistNotificationUtils {
      * @param Ctor - Custom IPersistNotificationInstance constructor
      */
     usePersistNotificationAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_PERSIST_NOTIFICATION_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_PERSIST_NOTIFICATION_ADAPTER);
         this.PersistNotificationInstanceCtor = Ctor;
         this.getNotificationStorage.clear();
     }
@@ -2829,21 +2857,21 @@ class PersistNotificationUtils {
      * instances are created with the updated base path.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_CLEAR);
         this.getNotificationStorage.clear();
     }
     /**
      * Switches to the default file-based PersistNotificationInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistNotificationAdapter(PersistNotificationInstance);
     }
     /**
      * Switches to PersistNotificationDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistNotificationAdapter(PersistNotificationDummyInstance);
     }
 }
@@ -2967,7 +2995,7 @@ class PersistLogUtils {
          * @returns Promise resolving to array of log entries
          */
         this.readLogData = async () => {
-            LOGGER_SERVICE$7.info(PERSIST_LOG_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_LOG_UTILS_METHOD_NAME_READ_DATA);
             const isInitial = !this._logInstance;
             const instance = this.getLogInstance();
             await instance.waitForInit(isInitial);
@@ -2981,7 +3009,7 @@ class PersistLogUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeLogData = async (logData) => {
-            LOGGER_SERVICE$7.info(PERSIST_LOG_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.info(PERSIST_LOG_UTILS_METHOD_NAME_WRITE_DATA);
             const isInitial = !this._logInstance;
             const instance = this.getLogInstance();
             await instance.waitForInit(isInitial);
@@ -3006,7 +3034,7 @@ class PersistLogUtils {
      * @param Ctor - Custom IPersistLogInstance constructor
      */
     usePersistLogAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_LOG_UTILS_METHOD_NAME_USE_PERSIST_LOG_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_LOG_UTILS_METHOD_NAME_USE_PERSIST_LOG_ADAPTER);
         this.PersistLogInstanceCtor = Ctor;
         this._logInstance = null;
     }
@@ -3015,21 +3043,21 @@ class PersistLogUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_LOG_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_LOG_UTILS_METHOD_NAME_CLEAR);
         this._logInstance = null;
     }
     /**
      * Switches to the default file-based PersistLogInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistLogAdapter(PersistLogInstance);
     }
     /**
      * Switches to PersistLogDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistLogAdapter(PersistLogDummyInstance);
     }
 }
@@ -3191,7 +3219,7 @@ class PersistMeasureUtils {
          * @returns Promise resolving to cached value, or null if not found / soft-deleted
          */
         this.readMeasureData = async (bucket, key) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
+            LOGGER_SERVICE$8.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);
@@ -3207,7 +3235,7 @@ class PersistMeasureUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeMeasureData = async (data, bucket, key, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
+            LOGGER_SERVICE$8.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);
@@ -3222,7 +3250,7 @@ class PersistMeasureUtils {
          * @returns Promise that resolves when removal is complete
          */
         this.removeMeasureData = async (bucket, key) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
+            LOGGER_SERVICE$8.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);
@@ -3236,7 +3264,7 @@ class PersistMeasureUtils {
      * @param Ctor - Custom IPersistMeasureInstance constructor
      */
     usePersistMeasureAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_PERSIST_MEASURE_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_PERSIST_MEASURE_ADAPTER);
         this.PersistMeasureInstanceCtor = Ctor;
         this.getMeasureStorage.clear();
     }
@@ -3248,7 +3276,7 @@ class PersistMeasureUtils {
      * @returns AsyncGenerator yielding entry keys
      */
     async *listMeasureData(bucket) {
-        LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_LIST_DATA, { bucket });
+        LOGGER_SERVICE$8.info(PERSIST_MEASURE_UTILS_METHOD_NAME_LIST_DATA, { bucket });
         const isInitial = !this.getMeasureStorage.has(bucket);
         const instance = this.getMeasureStorage(bucket);
         await instance.waitForInit(isInitial);
@@ -3259,21 +3287,21 @@ class PersistMeasureUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_MEASURE_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_MEASURE_UTILS_METHOD_NAME_CLEAR);
         this.getMeasureStorage.clear();
     }
     /**
      * Switches to the default file-based PersistMeasureInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistMeasureAdapter(PersistMeasureInstance);
     }
     /**
      * Switches to PersistMeasureDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistMeasureAdapter(PersistMeasureDummyInstance);
     }
 }
@@ -3432,7 +3460,7 @@ class PersistIntervalUtils {
          * @returns Promise resolving to marker data, or null if not found / soft-deleted
          */
         this.readIntervalData = async (bucket, key) => {
-            LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
+            LOGGER_SERVICE$8.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);
@@ -3448,7 +3476,7 @@ class PersistIntervalUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeIntervalData = async (data, bucket, key, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
+            LOGGER_SERVICE$8.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);
@@ -3463,7 +3491,7 @@ class PersistIntervalUtils {
          * @returns Promise that resolves when removal is complete
          */
         this.removeIntervalData = async (bucket, key) => {
-            LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
+            LOGGER_SERVICE$8.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);
@@ -3477,7 +3505,7 @@ class PersistIntervalUtils {
      * @param Ctor - Custom IPersistIntervalInstance constructor
      */
     usePersistIntervalAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_PERSIST_INTERVAL_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_PERSIST_INTERVAL_ADAPTER);
         this.PersistIntervalInstanceCtor = Ctor;
         this.getIntervalStorage.clear();
     }
@@ -3489,7 +3517,7 @@ class PersistIntervalUtils {
      * @returns AsyncGenerator yielding marker keys
      */
     async *listIntervalData(bucket) {
-        LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_LIST_DATA, { bucket });
+        LOGGER_SERVICE$8.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_LIST_DATA, { bucket });
         const isInitial = !this.getIntervalStorage.has(bucket);
         const instance = this.getIntervalStorage(bucket);
         await instance.waitForInit(isInitial);
@@ -3500,21 +3528,21 @@ class PersistIntervalUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_CLEAR);
         this.getIntervalStorage.clear();
     }
     /**
      * Switches to the default file-based PersistIntervalInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistIntervalAdapter(PersistIntervalInstance);
     }
     /**
      * Switches to PersistIntervalDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistIntervalAdapter(PersistIntervalDummyInstance);
     }
 }
@@ -3720,7 +3748,7 @@ class PersistMemoryUtils {
          * @returns Promise resolving to entry data, or null if not found / soft-deleted
          */
         this.readMemoryData = async (signalId, bucketName, memoryId) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$8.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);
@@ -3737,7 +3765,7 @@ class PersistMemoryUtils {
          * @returns Promise resolving to true if entry exists
          */
         this.hasMemoryData = async (signalId, bucketName, memoryId) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_HAS_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$8.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);
@@ -3756,7 +3784,7 @@ class PersistMemoryUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeMemoryData = async (data, signalId, bucketName, memoryId, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$8.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);
@@ -3773,7 +3801,7 @@ class PersistMemoryUtils {
          * @returns Promise that resolves when removal is complete
          */
         this.removeMemoryData = async (signalId, bucketName, memoryId) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_REMOVE_DATA, { signalId, bucketName, memoryId });
+            LOGGER_SERVICE$8.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);
@@ -3785,7 +3813,7 @@ class PersistMemoryUtils {
          * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
-            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_CLEAR);
+            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_CLEAR);
             this.getMemoryStorage.clear();
         };
         /**
@@ -3796,7 +3824,7 @@ class PersistMemoryUtils {
          * @param bucketName - Bucket name
          */
         this.dispose = (signalId, bucketName) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_DISPOSE);
+            LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_DISPOSE);
             const key = `${signalId}:${bucketName}`;
             this.getMemoryStorage.clear(key);
         };
@@ -3808,7 +3836,7 @@ class PersistMemoryUtils {
      * @param Ctor - Custom IPersistMemoryInstance constructor
      */
     usePersistMemoryAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_USE_PERSIST_MEMORY_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_MEMORY_UTILS_METHOD_NAME_USE_PERSIST_MEMORY_ADAPTER);
         this.PersistMemoryInstanceCtor = Ctor;
         this.getMemoryStorage.clear();
     }
@@ -3822,7 +3850,7 @@ class PersistMemoryUtils {
      * @returns AsyncGenerator yielding `{ memoryId, data }` tuples
      */
     async *listMemoryData(signalId, bucketName) {
-        LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_LIST_DATA, { signalId, bucketName });
+        LOGGER_SERVICE$8.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);
@@ -3833,14 +3861,14 @@ class PersistMemoryUtils {
      * Switches to the default file-based PersistMemoryInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistMemoryAdapter(PersistMemoryInstance);
     }
     /**
      * Switches to PersistMemoryDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistMemoryAdapter(PersistMemoryDummyInstance);
     }
 }
@@ -3989,7 +4017,7 @@ class PersistRecentUtils {
          * @returns Promise resolving to recent signal or null if none persisted
          */
         this.readRecentData = async (symbol, strategyName, exchangeName, frameName, backtest) => {
-            LOGGER_SERVICE$7.info(PERSIST_RECENT_UTILS_METHOD_NAME_READ_DATA);
+            LOGGER_SERVICE$8.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);
@@ -4010,7 +4038,7 @@ class PersistRecentUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeRecentData = async (signalRow, symbol, strategyName, exchangeName, frameName, backtest, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_RECENT_UTILS_METHOD_NAME_WRITE_DATA);
+            LOGGER_SERVICE$8.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);
@@ -4043,7 +4071,7 @@ class PersistRecentUtils {
      * @param Ctor - Custom IPersistRecentInstance constructor
      */
     usePersistRecentAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_RECENT_UTILS_METHOD_NAME_USE_PERSIST_RECENT_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_RECENT_UTILS_METHOD_NAME_USE_PERSIST_RECENT_ADAPTER);
         this.PersistRecentInstanceCtor = Ctor;
         this.getStorage.clear();
     }
@@ -4052,21 +4080,21 @@ class PersistRecentUtils {
      * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
-        LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_CLEAR);
+        LOGGER_SERVICE$8.log(PERSIST_RECENT_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
      * Switches to the default file-based PersistRecentInstance.
      */
     useJson() {
-        LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_JSON);
+        LOGGER_SERVICE$8.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_JSON);
         this.usePersistRecentAdapter(PersistRecentInstance);
     }
     /**
      * Switches to PersistRecentDummyInstance (all operations are no-ops).
      */
     useDummy() {
-        LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_DUMMY);
+        LOGGER_SERVICE$8.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_DUMMY);
         this.usePersistRecentAdapter(PersistRecentDummyInstance);
     }
 }
@@ -4201,7 +4229,7 @@ class PersistStateUtils {
          * @returns Promise that resolves when initialization is complete
          */
         this.waitForInit = async (signalId, bucketName, initial) => {
-            LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_WAIT_FOR_INIT, { signalId, bucketName, initial });
+            LOGGER_SERVICE$8.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);
@@ -4216,7 +4244,7 @@ class PersistStateUtils {
          * @returns Promise resolving to state data or null if none persisted
          */
         this.readStateData = async (signalId, bucketName) => {
-            LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName });
+            LOGGER_SERVICE$8.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);
@@ -4234,7 +4262,7 @@ class PersistStateUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeStateData = async (data, signalId, bucketName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName });
+            LOGGER_SERVICE$8.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);
@@ -4245,14 +4273,14 @@ class PersistStateUtils {
          * Switches to PersistStateDummyInstance (all operations are no-ops).
          */
         this.useDummy = () => {
-            LOGGER_SERVICE$7.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_DUMMY);
+            LOGGER_SERVICE$8.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_DUMMY);
             this.usePersistStateAdapter(PersistStateDummyInstance);
         };
         /**
          * Switches to the default file-based PersistStateInstance.
          */
         this.useJson = () => {
-            LOGGER_SERVICE$7.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_JSON);
+            LOGGER_SERVICE$8.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_JSON);
             this.usePersistStateAdapter(PersistStateInstance);
         };
         /**
@@ -4260,7 +4288,7 @@ class PersistStateUtils {
          * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
-            LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_CLEAR);
+            LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_CLEAR);
             this.getStateStorage.clear();
         };
         /**
@@ -4271,7 +4299,7 @@ class PersistStateUtils {
          * @param bucketName - Bucket name
          */
         this.dispose = (signalId, bucketName) => {
-            LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_DISPOSE);
+            LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_DISPOSE);
             const key = `${signalId}:${bucketName}`;
             this.getStateStorage.clear(key);
         };
@@ -4283,7 +4311,7 @@ class PersistStateUtils {
      * @param Ctor - Custom IPersistStateInstance constructor
      */
     usePersistStateAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_USE_PERSIST_STATE_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_STATE_UTILS_METHOD_NAME_USE_PERSIST_STATE_ADAPTER);
         this.PersistStateInstanceCtor = Ctor;
         this.getStateStorage.clear();
     }
@@ -4423,7 +4451,7 @@ class PersistSessionUtils {
          * @returns Promise that resolves when initialization is complete
          */
         this.waitForInit = async (strategyName, exchangeName, frameName, initial) => {
-            LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_WAIT_FOR_INIT, { strategyName, exchangeName, frameName, initial });
+            LOGGER_SERVICE$8.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);
@@ -4439,7 +4467,7 @@ class PersistSessionUtils {
          * @returns Promise resolving to session data or null if none persisted
          */
         this.readSessionData = async (strategyName, exchangeName, frameName) => {
-            LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_READ_DATA, { strategyName, exchangeName, frameName });
+            LOGGER_SERVICE$8.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);
@@ -4458,7 +4486,7 @@ class PersistSessionUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeSessionData = async (data, strategyName, exchangeName, frameName, when) => {
-            LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_WRITE_DATA, { strategyName, exchangeName, frameName });
+            LOGGER_SERVICE$8.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);
@@ -4469,14 +4497,14 @@ class PersistSessionUtils {
          * Switches to PersistSessionDummyInstance (all operations are no-ops).
          */
         this.useDummy = () => {
-            LOGGER_SERVICE$7.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_DUMMY);
+            LOGGER_SERVICE$8.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_DUMMY);
             this.usePersistSessionAdapter(PersistSessionDummyInstance);
         };
         /**
          * Switches to the default file-based PersistSessionInstance.
          */
         this.useJson = () => {
-            LOGGER_SERVICE$7.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_JSON);
+            LOGGER_SERVICE$8.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_JSON);
             this.usePersistSessionAdapter(PersistSessionInstance);
         };
         /**
@@ -4484,7 +4512,7 @@ class PersistSessionUtils {
          * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
-            LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_CLEAR);
+            LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_CLEAR);
             this.getSessionStorage.clear();
         };
         /**
@@ -4496,7 +4524,7 @@ class PersistSessionUtils {
          * @param frameName - Frame identifier
          */
         this.dispose = (strategyName, exchangeName, frameName) => {
-            LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_DISPOSE);
+            LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_DISPOSE);
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             this.getSessionStorage.clear(key);
         };
@@ -4508,7 +4536,7 @@ class PersistSessionUtils {
      * @param Ctor - Custom IPersistSessionInstance constructor
      */
     usePersistSessionAdapter(Ctor) {
-        LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_USE_PERSIST_SESSION_ADAPTER);
+        LOGGER_SERVICE$8.info(PERSIST_SESSION_UTILS_METHOD_NAME_USE_PERSIST_SESSION_ADAPTER);
         this.PersistSessionInstanceCtor = Ctor;
         this.getSessionStorage.clear();
     }
@@ -4520,28 +4548,39 @@ class PersistSessionUtils {
 const PersistSessionAdapter = new PersistSessionUtils();
 
 var _a$2, _b$2;
-const BUSY_DELAY = 100;
 const SET_BUSY_SYMBOL = Symbol("setBusy");
 const GET_BUSY_SYMBOL = Symbol("getBusy");
 const ACQUIRE_LOCK_SYMBOL = Symbol("acquireLock");
 const RELEASE_LOCK_SYMBOL = Symbol("releaseLock");
+/**
+ * Body of the queued acquire operation.
+ *
+ * Parks the caller on `self._tick` whenever the lock is already busy: each
+ * `releaseLock` emits on `_tick`, waking exactly the next queued acquirer
+ * instead of polling on a fixed delay. The busy counter is bumped only after
+ * the loop exits, so re-entry checks remain coherent under contention.
+ *
+ * @param self - The owning {@link Lock} instance.
+ */
 const ACQUIRE_LOCK_FN = async (self) => {
     while (self[GET_BUSY_SYMBOL]()) {
-        await functoolsKit.sleep(BUSY_DELAY);
+        // @ts-ignore
+        await self._tick.toPromise();
     }
     self[SET_BUSY_SYMBOL](true);
 };
 /**
  * Mutual exclusion primitive for async TypeScript code.
  *
- * Provides a reentrant-safe, queued lock that serializes access to a critical
- * section across concurrent async callers. Internally tracks a busy counter so
- * nested acquire/release pairs are detected and mis-matched releases throw
- * immediately.
+ * Provides a queued lock that serializes access to a critical section across
+ * concurrent async callers. Wake-ups are event-driven (via an internal
+ * `_tick` subject emitted on every `releaseLock`) rather than polling,
+ * so contention does not incur a fixed delay.
  *
- * Three usage styles are supported:
+ * The busy counter detects mis-matched releases and throws immediately on
+ * extra `releaseLock` calls.
  *
- * **Manual acquire / release**
+ * **Usage**
  * ```ts
  * await lock.acquireLock();
  * try {
@@ -4556,7 +4595,18 @@ const ACQUIRE_LOCK_FN = async (self) => {
  */
 class Lock {
     constructor() {
+        /**
+         * Outstanding acquires that have not yet been released.
+         * Incremented in `[SET_BUSY_SYMBOL](true)`, decremented in `[SET_BUSY_SYMBOL](false)`.
+         * A negative value indicates an extra `releaseLock` and throws on detection.
+         */
         this._isBusy = 0;
+        /**
+         * Wake-up channel for {@link ACQUIRE_LOCK_FN}.
+         * Every {@link releaseLock} emits a single tick that unblocks the next
+         * queued acquirer parked on `toPromise()`.
+         */
+        this._tick = new functoolsKit.Subject();
         this[_a$2] = functoolsKit.queued(ACQUIRE_LOCK_FN);
         this[_b$2] = () => this[SET_BUSY_SYMBOL](false);
         /**
@@ -4577,16 +4627,19 @@ class Lock {
             await this[ACQUIRE_LOCK_SYMBOL](this);
         };
         /**
-         * Releases the lock previously acquired with {@link acquireLock}.
+         * Releases the lock previously acquired with {@link acquireLock} and emits
+         * on the internal `_tick` subject to wake the next queued acquirer.
+         *
          * Must be called exactly once per successful {@link acquireLock} call,
-         * typically inside a `finally` block. Throws if called more times
-         * than the lock was acquired.
+         * typically inside a `finally` block. Throws if called more times than
+         * the lock was acquired.
          *
          * @returns {Promise<void>} Resolves once the lock has been released.
          * @throws {Error} If the lock is released more times than it was acquired.
          */
         this.releaseLock = async () => {
             await this[RELEASE_LOCK_SYMBOL]();
+            await this._tick.next();
         };
     }
     [SET_BUSY_SYMBOL](isBusy) {
@@ -4601,18 +4654,166 @@ class Lock {
 }
 _a$2 = ACQUIRE_LOCK_SYMBOL, _b$2 = RELEASE_LOCK_SYMBOL;
 
+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();
+/**
+ * Builds the composite {@link Key} used to register an activity in `_lookupMap`.
+ *
+ * Mirrors the {@link Key} type construction: appends `frameName` only when provided
+ * (typical for backtest), then a `"backtest"` / `"live"` discriminator suffix.
+ *
+ * @param symbol - Trading pair symbol.
+ * @param strategyName - Strategy schema name.
+ * @param exchangeName - Exchange schema name.
+ * @param frameName - Frame schema name; omitted from the key when falsy.
+ * @param backtest - `true` for backtest, `false` for live.
+ * @returns Colon-joined composite key.
+ */
+const CREATE_KEY_FN$y = (symbol, strategyName, exchangeName, frameName, backtest) => {
+    const parts = [symbol, strategyName, exchangeName];
+    if (frameName)
+        parts.push(frameName);
+    parts.push(backtest ? "backtest" : "live");
+    return parts.join(":");
+};
+/**
+ * In-memory registry of currently running backtest and live activities.
+ *
+ * Purpose:
+ * - Each `Backtest.run` / `Live.run` / per-strategy walker iteration registers an
+ *   {@link IActivityEntry} on start and removes it on completion.
+ * - `Candle.spinLock` consults {@link isParallel} to decide whether the event-loop
+ *   hand-off (post-candle-fetch spin) is worth performing. With a single active
+ *   workload there is no peer to yield to, so the spin is skipped entirely.
+ *
+ * Exposed as the `Lookup` singleton; no constructor parameters.
+ *
+ * @example
+ * ```typescript
+ * Lookup.addActivity({ symbol: "BTCUSDT", context, backtest: true });
+ * try {
+ *   for await (const _ of run(symbol, context)) { ... }
+ * } finally {
+ *   Lookup.removeActivity({ symbol: "BTCUSDT", context, backtest: true });
+ * }
+ * ```
+ */
+class LookupUtils {
+    constructor() {
+        /** Active entries keyed by their composite {@link Key}. */
+        this._lookupMap = new Map();
+        /**
+         * Registers a backtest or live activity in the lookup map.
+         * Idempotent for identical keys — duplicate calls overwrite the existing entry.
+         *
+         * @param activity - Activity descriptor identifying the running workload.
+         */
+        this.addActivity = (activity) => {
+            LOGGER_SERVICE$7.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);
+            this._lookupMap.set(key, activity);
+        };
+        /**
+         * Removes a previously registered activity from the lookup map.
+         * Must be paired with a prior {@link addActivity}, typically in a `finally` block,
+         * so a thrown error in the underlying run does not leave a stale entry behind.
+         *
+         * @param activity - Activity descriptor matching the one passed to {@link addActivity}.
+         */
+        this.removeActivity = (activity) => {
+            LOGGER_SERVICE$7.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);
+            this._lookupMap.delete(key);
+        };
+        /**
+         * Returns a snapshot of currently active entries.
+         *
+         * @returns Array of all activities present in the lookup map at call time.
+         */
+        this.listActivity = () => {
+            LOGGER_SERVICE$7.info(METHOD_NAME_LIST_ACTIVITY);
+            return Array.from(this._lookupMap.values());
+        };
+    }
+    /**
+     * `true` when more than one activity is currently registered.
+     * Used by `Candle.spinLock` to decide whether yielding the event loop is useful.
+     */
+    get isParallel() {
+        return this._lookupMap.size > 1;
+    }
+}
+/**
+ * Process-wide singleton instance of {@link LookupUtils}.
+ * Imported by `Backtest`, `Live`, `WalkerLogicPrivateService` (registration sites)
+ * and by `Candle` (read-only consumer via `isParallel`).
+ */
+const Lookup = new LookupUtils();
+
 const METHOD_NAME_ACQUIRE_LOCK = "CandleUtils.acquireLock";
 const METHOD_NAME_RELEASE_LOCK = "CandleUtils.releaseLock";
+const METHOD_NAME_SPIN_LOCK = "CandleUtils.spinLock";
+/**
+ * Upper bound (ms) on how long `spinLock` may park before falling through.
+ * If no peer backtest acquires the candle-fetch mutex within this window,
+ * the spinner proceeds without further yielding.
+ */
+const ROTATE_DELAY = 50;
 /** Logger service injected as DI singleton */
 const LOGGER_SERVICE$6 = new LoggerService();
+/**
+ * Process-wide coordinator for candle-fetch serialization and cooperative
+ * yielding between parallel backtests.
+ *
+ * Two complementary primitives are exposed:
+ * - **Mutex** via {@link acquireLock} / {@link releaseLock}: prevents concurrent
+ *   candle fetches from racing on the same exchange.
+ * - **Spin hand-off** via {@link spinLock}: invoked after a fetch completes to
+ *   give peer backtests waiting on the mutex a chance to run, so multiple
+ *   `Backtest.run` workloads interleave instead of one monopolizing the loop.
+ *
+ * All three operations are no-ops when `CC_ENABLE_CANDLE_FETCH_MUTEX` is `false`.
+ * The spin additionally requires `CC_ENABLE_BACKTEST_PARALLEL_SPIN` and at least
+ * two registered activities in `Lookup` (see `Lookup.isParallel`).
+ *
+ * @example
+ * ```typescript
+ * await Candle.acquireLock("ClientExchange GET_CANDLES_FN");
+ * try {
+ *   const candles = await fetchFromExchange(...);
+ *   return candles;
+ * } finally {
+ *   await Candle.releaseLock("ClientExchange GET_CANDLES_FN");
+ * }
+ * // Elsewhere, after a fetch completes inside a backtest loop:
+ * await Candle.spinLock("BacktestLogicPrivateService GET_CANDLES_FN");
+ * ```
+ */
 class CandleUtils {
     constructor() {
+        /** Underlying mutex serializing candle fetches across concurrent callers. */
         this._lock = new Lock();
         /**
-         * Acquires the candle fetch mutex if CC_ENABLE_CANDLE_FETCH_MUTEX is enabled.
+         * Emits whenever {@link acquireLock} successfully takes the mutex.
+         * Awaited by {@link spinLock} to detect that a peer backtest has just
+         * started its own fetch — the signal that yielding now will be productive.
+         */
+        this._spin = new functoolsKit.Subject();
+        /**
+         * Acquires the candle fetch mutex if `CC_ENABLE_CANDLE_FETCH_MUTEX` is enabled.
          * Prevents concurrent candle fetches from the same exchange.
          *
-         * @param source - Caller identifier for logging
+         * On successful acquisition, emits on the internal spin subject so any
+         * peer parked inside {@link spinLock} can wake up and proceed.
+         *
+         * @param source - Caller identifier for logging.
          */
         this.acquireLock = async (source) => {
             LOGGER_SERVICE$6.info(METHOD_NAME_ACQUIRE_LOCK, {
@@ -4621,13 +4822,14 @@ class CandleUtils {
             if (!GLOBAL_CONFIG.CC_ENABLE_CANDLE_FETCH_MUTEX) {
                 return;
             }
-            return await this._lock.acquireLock();
+            await this._lock.acquireLock();
+            await this._spin.next();
         };
         /**
-         * Releases the candle fetch mutex if CC_ENABLE_CANDLE_FETCH_MUTEX is enabled.
-         * Must be called after acquireLock, typically in a finally block.
+         * Releases the candle fetch mutex if `CC_ENABLE_CANDLE_FETCH_MUTEX` is enabled.
+         * Must be called after {@link acquireLock}, typically in a `finally` block.
          *
-         * @param source - Caller identifier for logging
+         * @param source - Caller identifier for logging.
          */
         this.releaseLock = async (source) => {
             LOGGER_SERVICE$6.info(METHOD_NAME_RELEASE_LOCK, {
@@ -4638,8 +4840,47 @@ class CandleUtils {
             }
             return await this._lock.releaseLock();
         };
+        /**
+         * Cooperative event-loop hand-off invoked by `BacktestLogicPrivateService`
+         * after a successful `getNextCandles`. Allows peer backtests waiting on the
+         * candle-fetch mutex to run before the current backtest fetches the next chunk.
+         *
+         * Waits for one of:
+         * - a peer calling {@link acquireLock} (signalled via the spin subject), or
+         * - a `ROTATE_DELAY` ms timeout, so the caller never parks indefinitely.
+         *
+         * Returns immediately as a no-op when any of these is true:
+         * - `CC_ENABLE_CANDLE_FETCH_MUTEX` is disabled (mutex is off entirely),
+         * - `CC_ENABLE_BACKTEST_PARALLEL_SPIN` is disabled (cooperative yielding off),
+         * - `Lookup.isParallel` is `false` (only one active workload — no peer to yield to).
+         *
+         * @param source - Caller identifier for logging.
+         */
+        this.spinLock = async (source) => {
+            LOGGER_SERVICE$6.info(METHOD_NAME_SPIN_LOCK, {
+                source,
+            });
+            if (!GLOBAL_CONFIG.CC_ENABLE_CANDLE_FETCH_MUTEX) {
+                return;
+            }
+            if (!GLOBAL_CONFIG.CC_ENABLE_BACKTEST_PARALLEL_SPIN) {
+                return;
+            }
+            if (!Lookup.isParallel) {
+                return;
+            }
+            await Promise.race([
+                this._spin.toPromise(),
+                functoolsKit.sleep(ROTATE_DELAY),
+            ]);
+        };
     }
 }
+/**
+ * Process-wide singleton instance of {@link CandleUtils}.
+ * Imported by `ClientExchange` (mutex around exchange fetches) and by
+ * `BacktestLogicPrivateService` (spin hand-off between parallel backtests).
+ */
 const Candle = new CandleUtils();
 
 const MS_PER_MINUTE$7 = 60000;
@@ -19173,9 +19414,28 @@ const TICK_FN = async (self, symbol, when) => {
         return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "TICK_FN", message: functoolsKit.getErrorMessage(error) };
     }
 };
+/**
+ * Wraps `exchangeCoreService.getNextCandles` with error capture and a cooperative
+ * event-loop hand-off after a successful fetch.
+ *
+ * Calls `Candle.spinLock(...)` on success: when multiple backtests run in parallel
+ * (`Lookup.isParallel === true`), this yields the event loop so a peer waiting on
+ * the candle-fetch mutex can take its turn, producing round-robin interleaving
+ * instead of one backtest monopolizing the loop until completion. The spin is a
+ * no-op for single-workload runs.
+ *
+ * @param self - Owning service instance, used for logging and exchange access.
+ * @param symbol - Trading pair symbol.
+ * @param candlesNeeded - Number of 1m candles to request.
+ * @param bufferStartTime - Inclusive start time for the fetch window.
+ * @param logMeta - Extra structured fields appended to the warn log on failure.
+ * @returns Fetched candles, or a {@link TFnError} discriminated union on failure.
+ */
 const GET_CANDLES_FN = async (self, symbol, candlesNeeded, bufferStartTime, logMeta) => {
     try {
-        return await self.exchangeCoreService.getNextCandles(symbol, "1m", candlesNeeded, bufferStartTime, true);
+        const result = await self.exchangeCoreService.getNextCandles(symbol, "1m", candlesNeeded, bufferStartTime, true);
+        await Candle.spinLock("BacktestLogicPrivateService GET_CANDLES_FN");
+        return result;
     }
     catch (error) {
         console.error(`backtestLogicPrivateService getNextCandles failed symbol=${symbol} strategyName=${self.methodContextService.context.strategyName} exchangeName=${self.methodContextService.context.exchangeName}`);
@@ -20061,6 +20321,15 @@ class WalkerLogicPrivateService {
                     exchangeName: context.exchangeName,
                     frameName: context.frameName,
                 });
+                Lookup.addActivity({
+                    symbol,
+                    context: {
+                        strategyName,
+                        exchangeName: context.exchangeName,
+                        frameName: context.frameName,
+                    },
+                    backtest: true,
+                });
                 try {
                     await functoolsKit.resolveDocuments(iterator);
                 }
@@ -20076,6 +20345,17 @@ class WalkerLogicPrivateService {
                     await CALL_STRATEGY_ERROR_CALLBACKS_FN(this, walkerSchema, strategyName, symbol, error);
                     continue;
                 }
+                finally {
+                    Lookup.removeActivity({
+                        symbol,
+                        context: {
+                            strategyName,
+                            exchangeName: context.exchangeName,
+                            frameName: context.frameName,
+                        },
+                        backtest: true,
+                    });
+                }
                 this.loggerService.info("walkerLogicPrivateService backtest complete", {
                     strategyName,
                     symbol,
@@ -20152,6 +20432,110 @@ class WalkerLogicPrivateService {
     }
 }
 
+/**
+ * Run iterator function for backtest logic.
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param context - Execution context with strategy, exchange, and frame names
+ * @param self - Instance of BacktestLogicPublicService
+ * @returns Async iterator for backtest results
+ */
+const RUN_ITERATOR_FN$1 = (self, symbol, context) => {
+    return MethodContextService.runAsyncIterator(self.backtestLogicPrivateService.run(symbol), {
+        exchangeName: context.exchangeName,
+        strategyName: context.strategyName,
+        frameName: context.frameName,
+    });
+};
+/**
+ * Call before start execution for backtest logic.
+ * This function is responsible for triggering the beforeStartSubject
+ * with the appropriate context and symbol information.
+ */
+const CALL_BEFORE_START_FN$1 = functoolsKit.trycatch(async (self, symbol, context) => {
+    const { startDate } = self.frameSchemaService.get(context.frameName);
+    const when = alignToInterval(startDate, "1m");
+    await MethodContextService.runInContext(async () => {
+        await ExecutionContextService.runInContext(async () => {
+            const currentPrice = await self.exchangeConnectionService.getAveragePrice(symbol);
+            await beforeStartSubject.next({
+                symbol,
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+                backtest: true,
+                when,
+                timestamp: when.getTime(),
+                currentPrice,
+            });
+        }, {
+            symbol,
+            when,
+            backtest: true,
+        });
+    }, {
+        exchangeName: context.exchangeName,
+        strategyName: context.strategyName,
+        frameName: context.frameName,
+    });
+}, {
+    fallback: (error, self) => {
+        const message = "BacktestLogicPublicService CALL_BEFORE_START_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Call after end execution for backtest logic.
+ * This function is responsible for triggering the afterEndSubject
+ * with the appropriate context and symbol information.
+ */
+const CALL_AFTER_END_FN$1 = functoolsKit.trycatch(async (self, symbol, context) => {
+    const { startDate } = self.frameSchemaService.get(context.frameName);
+    const timestamp = self.timeMetaService.hasTimestamp(symbol, context, true)
+        ? await self.timeMetaService.getTimestamp(symbol, context, true)
+        : startDate.getTime();
+    const when = new Date(timestamp);
+    await MethodContextService.runInContext(async () => {
+        await ExecutionContextService.runInContext(async () => {
+            const currentPrice = await self.exchangeConnectionService.getAveragePrice(symbol);
+            await afterEndSubject.next({
+                symbol,
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+                backtest: true,
+                when,
+                timestamp,
+                currentPrice,
+            });
+        }, {
+            symbol,
+            when,
+            backtest: true,
+        });
+    }, {
+        exchangeName: context.exchangeName,
+        strategyName: context.strategyName,
+        frameName: context.frameName,
+    });
+}, {
+    fallback: (error, self) => {
+        const message = "BacktestLogicPublicService CALL_AFTER_END_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Public service for backtest orchestration with context management.
  *
@@ -20180,30 +20564,134 @@ class BacktestLogicPublicService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.backtestLogicPrivateService = inject(TYPES.backtestLogicPrivateService);
-        /**
-         * Runs backtest for a symbol with context propagation.
-         *
-         * Streams closed signals as async generator. Context is automatically
-         * injected into all framework functions called during iteration.
-         *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param context - Execution context with strategy, exchange, and frame names
-         * @returns Async generator yielding closed signals with PNL
-         */
-        this.run = (symbol, context) => {
-            this.loggerService.log("backtestLogicPublicService run", {
+        this.timeMetaService = inject(TYPES.timeMetaService);
+        this.frameSchemaService = inject(TYPES.frameSchemaService);
+        this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
+    }
+    /**
+     * Runs backtest for a symbol with context propagation.
+     *
+     * Streams closed signals as async generator. Context is automatically
+     * injected into all framework functions called during iteration.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context with strategy, exchange, and frame names
+     * @returns Async generator yielding closed signals with PNL
+     */
+    async *run(symbol, context) {
+        this.loggerService.log("backtestLogicPublicService run", {
+            symbol,
+            context,
+        });
+        await CALL_BEFORE_START_FN$1(this, symbol, context);
+        try {
+            yield* RUN_ITERATOR_FN$1(this, symbol, context);
+        }
+        finally {
+            await CALL_AFTER_END_FN$1(this, symbol, context);
+        }
+    }
+}
+
+/**
+ * Run iterator function for live logic.
+ *
+ * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+ * @param context - Execution context with strategy and exchange names
+ * @param self - Instance of LiveLogicPublicService
+ * @returns Async iterator for live trading results
+ */
+const RUN_ITERATOR_FN = (self, symbol, context) => {
+    return MethodContextService.runAsyncIterator(self.liveLogicPrivateService.run(symbol), {
+        exchangeName: context.exchangeName,
+        strategyName: context.strategyName,
+        frameName: "",
+    });
+};
+/**
+ * Call before start execution for live logic.
+ * This function is responsible for triggering the beforeStartSubject
+ * with the appropriate context and symbol information.
+ */
+const CALL_BEFORE_START_FN = functoolsKit.trycatch(async (self, symbol, context) => {
+    const when = alignToInterval(new Date(), "1m");
+    await MethodContextService.runInContext(async () => {
+        await ExecutionContextService.runInContext(async () => {
+            const currentPrice = await self.exchangeConnectionService.getAveragePrice(symbol);
+            await beforeStartSubject.next({
                 symbol,
-                context,
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: "",
+                backtest: false,
+                currentPrice,
+                when,
+                timestamp: when.getTime(),
             });
-            return MethodContextService.runAsyncIterator(this.backtestLogicPrivateService.run(symbol), {
+        }, {
+            symbol,
+            when,
+            backtest: false,
+        });
+    }, {
+        exchangeName: context.exchangeName,
+        strategyName: context.strategyName,
+        frameName: "",
+    });
+}, {
+    fallback: (error, self) => {
+        const message = "LiveLogicPublicService CALL_BEFORE_START_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Call after end execution for live logic.
+ * This function is responsible for triggering the afterEndSubject
+ * with the appropriate context and symbol information.
+ */
+const CALL_AFTER_END_FN = functoolsKit.trycatch(async (self, symbol, context) => {
+    const when = alignToInterval(new Date(), "1m");
+    await MethodContextService.runInContext(async () => {
+        await ExecutionContextService.runInContext(async () => {
+            const currentPrice = await self.exchangeConnectionService.getAveragePrice(symbol);
+            await afterEndSubject.next({
+                symbol,
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
-                frameName: context.frameName,
+                frameName: "",
+                backtest: false,
+                currentPrice,
+                when,
+                timestamp: when.getTime(),
             });
+        }, {
+            symbol,
+            when,
+            backtest: false,
+        });
+    }, {
+        exchangeName: context.exchangeName,
+        strategyName: context.strategyName,
+        frameName: "",
+    });
+}, {
+    fallback: (error, self) => {
+        const message = "LiveLogicPublicService CALL_AFTER_END_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
         };
-    }
-}
-
+        self.loggerService.warn(message, payload);
+        console.error(message, payload);
+        errorEmitter.next(error);
+    },
+});
 /**
  * Public service for live trading orchestration with context management.
  *
@@ -20239,28 +20727,31 @@ class LiveLogicPublicService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
         this.liveLogicPrivateService = inject(TYPES.liveLogicPrivateService);
-        /**
-         * Runs live trading for a symbol with context propagation.
-         *
-         * Streams opened and closed signals as infinite async generator.
-         * Context is automatically injected into all framework functions.
-         * Process can crash and restart - state will be recovered from disk.
-         *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param context - Execution context with strategy and exchange names
-         * @returns Infinite async generator yielding opened and closed signals
-         */
-        this.run = (symbol, context) => {
-            this.loggerService.log("liveLogicPublicService run", {
-                symbol,
-                context,
-            });
-            return MethodContextService.runAsyncIterator(this.liveLogicPrivateService.run(symbol), {
-                exchangeName: context.exchangeName,
-                strategyName: context.strategyName,
-                frameName: "",
-            });
-        };
+        this.exchangeConnectionService = inject(TYPES.exchangeConnectionService);
+    }
+    /**
+     * Runs live trading for a symbol with context propagation.
+     *
+     * Streams opened and closed signals as infinite async generator.
+     * Context is automatically injected into all framework functions.
+     * Process can crash and restart - state will be recovered from disk.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param context - Execution context with strategy and exchange names
+     * @returns Infinite async generator yielding opened and closed signals
+     */
+    async *run(symbol, context) {
+        this.loggerService.log("liveLogicPublicService run", {
+            symbol,
+            context,
+        });
+        await CALL_BEFORE_START_FN(this, symbol, context);
+        try {
+            yield* RUN_ITERATOR_FN(this, symbol, context);
+        }
+        finally {
+            await CALL_AFTER_END_FN(this, symbol, context);
+        }
     }
 }
 
@@ -34464,6 +34955,21 @@ class TimeMetaService {
          * Instances are cached until clear() is called.
          */
         this.getSource = functoolsKit.memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => CREATE_KEY_FN$a(symbol, strategyName, exchangeName, frameName, backtest), () => new functoolsKit.BehaviorSubject());
+        /**
+         * Checks if a timestamp exists for the given symbol and context.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Strategy, exchange, and frame identifiers
+         * @param backtest - True if backtest mode, false if live mode
+         * @returns True if a timestamp is available, false otherwise
+         */
+        this.hasTimestamp = (symbol, context, backtest) => {
+            const key = CREATE_KEY_FN$a(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            if (!this.getSource.has(key)) {
+                return false;
+            }
+            return !!this.getSource.get(key)?.data;
+        };
         /**
          * Returns the current candle timestamp (in milliseconds) for the given symbol and context.
          *
@@ -36095,6 +36601,7 @@ const Exchange = new ExchangeUtils();
 
 const WARM_CANDLES_METHOD_NAME = "cache.warmCandles";
 const CHECK_CANDLES_METHOD_NAME = "cache.checkCandles";
+const CACHE_CANDLES_METHOD_NAME = "cache.cacheCandles";
 const MS_PER_MINUTE$3 = 60000;
 const INTERVAL_MINUTES$3 = {
     "1m": 1,
@@ -36126,6 +36633,34 @@ const PRINT_PROGRESS_FN = (fetched, total, symbol, interval) => {
         process.stdout.write("\n");
     }
 };
+/**
+ * Retry-wrapped pipeline: validates the cache via `checkCandles` and, on miss,
+ * fills it via `warmCandles` and rethrows to trigger a retry pass that
+ * re-validates the freshly cached range. Limited to 2 attempts.
+ */
+const CACHE_CANDLES_FN = functoolsKit.retry(async (interval, dto, onWarmStart, onCheckStart) => {
+    try {
+        onCheckStart && onCheckStart(dto.symbol, interval, dto.from, dto.to);
+        await checkCandles({
+            exchangeName: dto.exchangeName,
+            from: dto.from,
+            to: dto.to,
+            symbol: dto.symbol,
+            interval: interval,
+        });
+    }
+    catch (error) {
+        onWarmStart && onWarmStart(dto.symbol, interval, dto.from, dto.to);
+        await warmCandles({
+            symbol: dto.symbol,
+            exchangeName: dto.exchangeName,
+            from: dto.from,
+            to: dto.to,
+            interval: interval,
+        });
+        throw error;
+    }
+}, 2);
 /**
  * Checks cached candle presence via the persist adapter.
  * Issues one ranged read; adapter-side `hasValue` covers each expected timestamp,
@@ -36201,6 +36736,34 @@ async function warmCandles(params) {
         PRINT_PROGRESS_FN(fetched, totalCandles, symbol, interval);
     }
 }
+/**
+ * Ensures candles for the given range are present in persist storage.
+ * Runs a check-then-warm pipeline with one retry: validates the cache first
+ * and, on a miss, downloads the missing data and re-validates.
+ *
+ * @param params - Combined cache parameters with optional lifecycle callbacks
+ */
+async function cacheCandles({ symbol, interval, from, to, exchangeName, onCheckStart = (symbol, interval, from, to) => {
+    process.stdout.write("\n");
+    process.stdout.write(`Checking candles cache for ${symbol} ${interval} from ${from} to ${to}\n`);
+}, onWarmStart = (symbol, interval, from, to) => {
+    process.stdout.write("\n\n");
+    process.stdout.write(`Caching candles for ${symbol} ${interval} from ${from} to ${to}\n`);
+}, }) {
+    backtest.loggerService.info(CACHE_CANDLES_METHOD_NAME, {
+        symbol,
+        exchangeName,
+        interval,
+        from,
+        to,
+    });
+    await CACHE_CANDLES_FN(interval, {
+        exchangeName,
+        from,
+        to,
+        symbol,
+    }, onWarmStart, onCheckStart);
+}
 
 const METHOD_NAME = "validate.validate";
 /**
@@ -36620,11 +37183,6 @@ const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
 const GET_CLOSE_PRICE_METHOD_NAME = "exchange.getClosePrice";
 const FORMAT_PRICE_METHOD_NAME = "exchange.formatPrice";
 const FORMAT_QUANTITY_METHOD_NAME = "exchange.formatQuantity";
-const GET_DATE_METHOD_NAME = "exchange.getDate";
-const GET_TIMESTAMP_METHOD_NAME = "exchange.getTimestamp";
-const GET_MODE_METHOD_NAME = "exchange.getMode";
-const GET_SYMBOL_METHOD_NAME = "exchange.getSymbol";
-const GET_CONTEXT_METHOD_NAME = "exchange.getContext";
 const HAS_TRADE_CONTEXT_METHOD_NAME = "exchange.hasTradeContext";
 const GET_ORDER_BOOK_METHOD_NAME = "exchange.getOrderBook";
 const GET_RAW_CANDLES_METHOD_NAME = "exchange.getRawCandles";
@@ -36791,113 +37349,6 @@ async function formatQuantity(symbol, quantity) {
     }
     return await backtest.exchangeConnectionService.formatQuantity(symbol, quantity);
 }
-/**
- * Gets the current date from execution context.
- *
- * In backtest mode: returns the current timeframe date being processed
- * In live mode: returns current real-time date
- *
- * @returns Promise resolving to current execution context date
- *
- * @example
- * ```typescript
- * const date = await getDate();
- * console.log(date); // 2024-01-01T12:00:00.000Z
- * ```
- */
-async function getDate() {
-    backtest.loggerService.info(GET_DATE_METHOD_NAME);
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("getDate requires an execution context");
-    }
-    const { when } = backtest.executionContextService.context;
-    return new Date(when.getTime());
-}
-/**
- * Gets the current timestamp from execution context.
- *
- * In backtest mode: returns the current timeframe timestamp being processed
- * In live mode: returns current real-time timestamp
- *
- * @returns Promise resolving to current execution context timestamp in milliseconds
- * @example
- * ```typescript
- * const timestamp = await getTimestamp();
- * console.log(timestamp); // 1700000000000
- * ```
- */
-async function getTimestamp() {
-    backtest.loggerService.info(GET_TIMESTAMP_METHOD_NAME);
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("getTimestamp requires an execution context");
-    }
-    return getContextTimestamp();
-}
-/**
- * Gets the current execution mode.
- *
- * @returns Promise resolving to "backtest" or "live"
- *
- * @example
- * ```typescript
- * const mode = await getMode();
- * if (mode === "backtest") {
- *   console.log("Running in backtest mode");
- * } else {
- *   console.log("Running in live mode");
- * }
- * ```
- */
-async function getMode() {
-    backtest.loggerService.info(GET_MODE_METHOD_NAME);
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("getMode requires an execution context");
-    }
-    const { backtest: bt } = backtest.executionContextService.context;
-    return bt ? "backtest" : "live";
-}
-/**
- * Gets the current trading symbol from execution context.
- *
- * @returns Promise resolving to the current trading symbol (e.g., "BTCUSDT")
- * @throws Error if execution context is not active
- *
- * @example
- * ```typescript
- * const symbol = await getSymbol();
- * console.log(symbol); // "BTCUSDT"
- * ```
- */
-async function getSymbol() {
-    backtest.loggerService.info(GET_SYMBOL_METHOD_NAME);
-    if (!ExecutionContextService.hasContext()) {
-        throw new Error("getSymbol requires an execution context");
-    }
-    const { symbol } = backtest.executionContextService.context;
-    return symbol;
-}
-/**
- * Gets the current method context.
- *
- * Returns the context object from the method context service, which contains
- * information about the current method execution environment.
- *
- * @returns Promise resolving to the current method context object
- * @throws Error if method context is not active
- *
- * @example
- * ```typescript
- * const context = await getContext();
- * console.log(context); // { ...method context data... }
- * ```
- */
-async function getContext() {
-    backtest.loggerService.info(GET_CONTEXT_METHOD_NAME);
-    if (!MethodContextService.hasContext()) {
-        throw new Error("getContext requires a method context");
-    }
-    return backtest.methodContextService.context;
-}
 /**
  * Fetches order book for a trading pair from the registered exchange.
  *
@@ -40438,6 +40889,10 @@ const LISTEN_MAX_DRAWDOWN_METHOD_NAME = "event.listenMaxDrawdown";
 const LISTEN_MAX_DRAWDOWN_ONCE_METHOD_NAME = "event.listenMaxDrawdownOnce";
 const LISTEN_SIGNAL_NOTIFY_METHOD_NAME = "event.listenSignalNotify";
 const LISTEN_SIGNAL_NOTIFY_ONCE_METHOD_NAME = "event.listenSignalNotifyOnce";
+const LISTEN_BEFORE_START_METHOD_NAME = "event.listenBeforeStart";
+const LISTEN_BEFORE_START_ONCE_METHOD_NAME = "event.listenBeforeStartOnce";
+const LISTEN_AFTER_END_METHOD_NAME = "event.listenAfterEnd";
+const LISTEN_AFTER_END_ONCE_METHOD_NAME = "event.listenAfterEndOnce";
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -41908,6 +42363,68 @@ function listenSignalNotifyOnce(filterFn, fn) {
     };
     return disposeFn = listenSignalNotify(wrappedFn);
 }
+/**
+ * Subscribes to before start events with queued async processing.
+ * Emits when the engine is about to start a new strategy execution for a symbol.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ * @param fn - Callback function to handle before start events
+ * @return Unsubscribe function to stop listening to events
+ */
+function listenBeforeStart(fn) {
+    backtest.loggerService.log(LISTEN_BEFORE_START_METHOD_NAME);
+    return beforeStartSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered before start events with one-time execution.
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes.
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @return Unsubscribe function to cancel the listener before it fires
+ */
+function listenBeforeStartOnce(filterFn, fn) {
+    backtest.loggerService.log(LISTEN_BEFORE_START_ONCE_METHOD_NAME);
+    let disposeFn;
+    const wrappedFn = async (event) => {
+        if (filterFn(event)) {
+            await fn(event);
+            disposeFn && disposeFn();
+        }
+    };
+    return disposeFn = listenBeforeStart(wrappedFn);
+}
+/**
+ * Subscribes to after end events with queued async processing.
+ * Emits when the engine has completed processing a strategy execution for a symbol.
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ * @param fn - Callback function to handle after end events
+ * @return Unsubscribe function to stop listening to events
+ */
+function listenAfterEnd(fn) {
+    backtest.loggerService.log(LISTEN_AFTER_END_METHOD_NAME);
+    return afterEndSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered after end events with one-time execution.
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes.
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @return Unsubscribe function to cancel the listener before it fires
+ */
+function listenAfterEndOnce(filterFn, fn) {
+    backtest.loggerService.log(LISTEN_AFTER_END_ONCE_METHOD_NAME);
+    let disposeFn;
+    const wrappedFn = async (event) => {
+        if (filterFn(event)) {
+            await fn(event);
+            disposeFn && disposeFn();
+        }
+    };
+    return disposeFn = listenAfterEnd(wrappedFn);
+}
 
 const BACKTEST_METHOD_NAME_RUN = "BacktestUtils.run";
 const BACKTEST_METHOD_NAME_BACKGROUND = "BacktestUtils.background";
@@ -41986,11 +42503,21 @@ const INSTANCE_TASK_FN$2 = async (symbol, context, self) => {
         self._isStopped = false;
         self._isDone = false;
     }
+    Lookup.addActivity({
+        symbol,
+        context,
+        backtest: true,
+    });
     for await (const _ of self.run(symbol, context)) {
         if (self._isStopped) {
             break;
         }
     }
+    Lookup.removeActivity({
+        symbol,
+        context,
+        backtest: true,
+    });
     if (!self._isDone) {
         await doneBacktestSubject.next({
             exchangeName: context.exchangeName,
@@ -44637,11 +45164,21 @@ const INSTANCE_TASK_FN$1 = async (symbol, context, self) => {
         self._isStopped = false;
         self._isDone = false;
     }
+    Lookup.addActivity({
+        symbol,
+        context,
+        backtest: false,
+    });
     for await (const signal of self.run(symbol, context)) {
         if (signal?.action === "closed" && self._isStopped) {
             break;
         }
     }
+    Lookup.removeActivity({
+        symbol,
+        context,
+        backtest: false,
+    });
     if (!self._isDone) {
         await doneLiveSubject.next({
             exchangeName: context.exchangeName,
@@ -48576,6 +49113,128 @@ async function listRiskSchema() {
     return await backtest.riskValidationService.list();
 }
 
+const GET_DATE_METHOD_NAME = "meta.getDate";
+const GET_TIMESTAMP_METHOD_NAME = "meta.getTimestamp";
+const GET_MODE_METHOD_NAME = "meta.getMode";
+const GET_SYMBOL_METHOD_NAME = "meta.getSymbol";
+const GET_CONTEXT_METHOD_NAME = "meta.getContext";
+/**
+ * Gets the current date from execution context.
+ *
+ * In backtest mode: returns the current timeframe date being processed
+ * In live mode: returns current real-time date
+ *
+ * @returns Promise resolving to current execution context date
+ *
+ * @example
+ * ```typescript
+ * const date = await getDate();
+ * console.log(date); // 2024-01-01T12:00:00.000Z
+ * ```
+ */
+async function getDate() {
+    backtest.loggerService.info(GET_DATE_METHOD_NAME);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getDate requires an execution context");
+    }
+    const { when } = backtest.executionContextService.context;
+    return new Date(when.getTime());
+}
+/**
+ * Gets the current timestamp from execution context.
+ *
+ * In backtest mode: returns the current timeframe timestamp being processed
+ * In live mode: returns current real-time timestamp
+ *
+ * @returns Promise resolving to current execution context timestamp in milliseconds
+ * @example
+ * ```typescript
+ * const timestamp = await getTimestamp();
+ * console.log(timestamp); // 1700000000000
+ * ```
+ */
+async function getTimestamp() {
+    backtest.loggerService.info(GET_TIMESTAMP_METHOD_NAME);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getTimestamp requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getTimestamp requires a method context");
+    }
+    const { symbol, backtest: isBacktest } = backtest.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = backtest.methodContextService.context;
+    return backtest.timeMetaService.getTimestamp(symbol, {
+        exchangeName,
+        frameName,
+        strategyName,
+    }, isBacktest);
+}
+/**
+ * Gets the current execution mode.
+ *
+ * @returns Promise resolving to "backtest" or "live"
+ *
+ * @example
+ * ```typescript
+ * const mode = await getMode();
+ * if (mode === "backtest") {
+ *   console.log("Running in backtest mode");
+ * } else {
+ *   console.log("Running in live mode");
+ * }
+ * ```
+ */
+async function getMode() {
+    backtest.loggerService.info(GET_MODE_METHOD_NAME);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getMode requires an execution context");
+    }
+    const { backtest: bt } = backtest.executionContextService.context;
+    return bt ? "backtest" : "live";
+}
+/**
+ * Gets the current trading symbol from execution context.
+ *
+ * @returns Promise resolving to the current trading symbol (e.g., "BTCUSDT")
+ * @throws Error if execution context is not active
+ *
+ * @example
+ * ```typescript
+ * const symbol = await getSymbol();
+ * console.log(symbol); // "BTCUSDT"
+ * ```
+ */
+async function getSymbol() {
+    backtest.loggerService.info(GET_SYMBOL_METHOD_NAME);
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("getSymbol requires an execution context");
+    }
+    const { symbol } = backtest.executionContextService.context;
+    return symbol;
+}
+/**
+ * Gets the current method context.
+ *
+ * Returns the context object from the method context service, which contains
+ * information about the current method execution environment.
+ *
+ * @returns Promise resolving to the current method context object
+ * @throws Error if method context is not active
+ *
+ * @example
+ * ```typescript
+ * const context = await getContext();
+ * console.log(context); // { ...method context data... }
+ * ```
+ */
+async function getContext() {
+    backtest.loggerService.info(GET_CONTEXT_METHOD_NAME);
+    if (!MethodContextService.hasContext()) {
+        throw new Error("getContext requires a method context");
+    }
+    return backtest.methodContextService.context;
+}
+
 const RECENT_PERSIST_BACKTEST_METHOD_NAME_HANDLE_ACTIVE_PING = "RecentPersistBacktestUtils.handleActivePing";
 const RECENT_PERSIST_BACKTEST_METHOD_NAME_GET_LATEST_SIGNAL = "RecentPersistBacktestUtils.getLatestSignal";
 const RECENT_PERSIST_LIVE_METHOD_NAME_HANDLE_ACTIVE_PING = "RecentPersistLiveUtils.handleActivePing";
@@ -54620,6 +55279,8 @@ const SUBJECT_ISOLATION_LIST = [
     syncSubject,
     validationSubject,
     signalNotifySubject,
+    beforeStartSubject,
+    afterEndSubject
 ];
 /**
  * Creates a snapshot function for a given subject by clearing its internal
@@ -63767,6 +64428,7 @@ exports.HighestProfit = HighestProfit;
 exports.Interval = Interval;
 exports.Live = Live;
 exports.Log = Log;
+exports.Lookup = Lookup;
 exports.Markdown = Markdown;
 exports.MarkdownFileBase = MarkdownFileBase;
 exports.MarkdownFolderBase = MarkdownFolderBase;
@@ -63848,6 +64510,7 @@ exports.addSizingSchema = addSizingSchema;
 exports.addStrategySchema = addStrategySchema;
 exports.addWalkerSchema = addWalkerSchema;
 exports.alignToInterval = alignToInterval;
+exports.cacheCandles = cacheCandles;
 exports.checkCandles = checkCandles;
 exports.commitActivateScheduled = commitActivateScheduled;
 exports.commitAverageBuy = commitAverageBuy;
@@ -63956,7 +64619,11 @@ exports.listStrategySchema = listStrategySchema;
 exports.listWalkerSchema = listWalkerSchema;
 exports.listenActivePing = listenActivePing;
 exports.listenActivePingOnce = listenActivePingOnce;
+exports.listenAfterEnd = listenAfterEnd;
+exports.listenAfterEndOnce = listenAfterEndOnce;
 exports.listenBacktestProgress = listenBacktestProgress;
+exports.listenBeforeStart = listenBeforeStart;
+exports.listenBeforeStartOnce = listenBeforeStartOnce;
 exports.listenBreakevenAvailable = listenBreakevenAvailable;
 exports.listenBreakevenAvailableOnce = listenBreakevenAvailableOnce;
 exports.listenDoneBacktest = listenDoneBacktest;