backtest-kit 8.5.0 → 9.0.0

package/build/index.mjs

@@ -1201,43 +1201,91 @@ _a$3 = BASE_WAIT_FOR_INIT_SYMBOL;
 // @ts-ignore
 PersistBase = makeExtendable(PersistBase);
 /**
- * Dummy persist adapter that discards all writes.
- * Used for disabling persistence.
+ * Default file-based implementation of IPersistSignalInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses symbol as entity ID within a per-context PersistBase
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistSignalInstance("BTCUSDT", "my-strategy", "binance");
+ * await instance.waitForInit(true);
+ * await instance.writeSignalData(signalRow);
+ * const restored = await instance.readSignalData();
+ * ```
  */
-class PersistDummy {
+class PersistSignalInstance {
     /**
-     * No-op initialization function.
-     * @returns Promise that resolves immediately
+     * Creates new signal persistence instance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
      */
-    async waitForInit() {
+    constructor(symbol, strategyName, exchangeName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this._storage = new PersistBase(`${symbol}_${strategyName}_${exchangeName}`, `./dump/data/signal/`);
     }
     /**
-     * No-op read function.
-     * @returns Promise that resolves with empty object
+     * Initializes the underlying PersistBase storage.
+     * Delegates to PersistBase.waitForInit which uses singleshot.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
      */
-    async readValue() {
-        return {};
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
     }
     /**
-     * No-op has value check.
-     * @returns Promise that resolves to false
+     * Reads the persisted signal using `symbol` as the entity key.
+     *
+     * @returns Promise resolving to the signal or null if not found
      */
-    async hasValue() {
-        return false;
+    async readSignalData() {
+        if (await this._storage.hasValue(this.symbol)) {
+            return await this._storage.readValue(this.symbol);
+        }
+        return null;
     }
     /**
-     * No-op write function.
-     * @returns Promise that resolves immediately
+     * Writes the signal (or null to clear) using `symbol` as the entity key.
+     *
+     * @param signalRow - Signal data to persist, or null to clear
+     * @returns Promise that resolves when write is complete
      */
-    async writeValue() {
+    async writeSignalData(signalRow) {
+        await this._storage.writeValue(this.symbol, signalRow);
     }
+}
+/**
+ * No-op IPersistSignalInstance implementation used by PersistSignalUtils.useDummy().
+ * All reads return null, all writes are discarded.
+ */
+class PersistSignalDummyInstance {
     /**
-     * No-op keys generator.
-     * @returns Empty async generator
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistSignalInstanceCtor.
      */
-    async *keys() {
-        // Empty generator - no keys
-    }
+    constructor(_symbol, _strategyName, _exchangeName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no persisted signal).
+     * @returns Promise resolving to null
+     */
+    async readSignalData() { return null; }
+    /**
+     * No-op write (discards data).
+     * @returns Promise that resolves immediately
+     */
+    async writeSignalData(_signalRow) { }
 }
 /**
  * Utility class for managing signal persistence.
@@ -1252,40 +1300,37 @@ class PersistDummy {
  */
 class PersistSignalUtils {
     constructor() {
-        this.PersistSignalFactory = PersistBase;
-        this.getStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistSignalFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/signal/`,
-        ]));
         /**
-         * Reads persisted signal data for a symbol and strategy.
-         *
-         * Called by ClientStrategy.waitForInit() to restore state.
-         * Returns null if no signal exists.
+         * Constructor used to create per-context signal instances.
+         * Replaceable via usePersistSignalAdapter() / useJson() / useDummy().
+         */
+        this.PersistSignalInstanceCtor = PersistSignalInstance;
+        /**
+         * Memoized factory creating one IPersistSignalInstance per (symbol, strategy, exchange) triple.
+         */
+        this.getStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistSignalInstanceCtor, [symbol, strategyName, exchangeName]));
+        /**
+         * Reads persisted signal for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to signal or null
+         * @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);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getStorage.has(key);
-            const stateStorage = this.getStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(symbol)) {
-                return await stateStorage.readValue(symbol);
-            }
-            return null;
+            const instance = this.getStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.readSignalData();
         };
         /**
-         * Writes signal data to disk with atomic file writes.
+         * Writes signal data (or null to clear) for the given context.
+         * Lazily initializes the instance on first access.
          *
-         * Called by ClientStrategy.setPendingSignal() to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
-         *
-         * @param signalRow - Signal data (null to clear)
+         * @param signalRow - Signal data to persist, or null to clear
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
@@ -1295,53 +1340,43 @@ class PersistSignalUtils {
             LOGGER_SERVICE$7.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getStorage.has(key);
-            const stateStorage = this.getStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(symbol, signalRow);
+            const instance = this.getStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.writeSignalData(signalRow);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistSignalInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
-     *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistSignalAdapter.usePersistSignalAdapter(RedisPersist);
-     * ```
+     * @param Ctor - Custom IPersistSignalInstance constructor
      */
     usePersistSignalAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
-        this.PersistSignalFactory = Ctor;
+        this.PersistSignalInstanceCtor = Ctor;
+        this.getStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistSignalInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistSignalAdapter(PersistBase);
+        this.usePersistSignalAdapter(PersistSignalInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistSignalDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistSignalAdapter(PersistDummy);
+        this.usePersistSignalAdapter(PersistSignalDummyInstance);
     }
 }
 /**
@@ -1361,6 +1396,92 @@ class PersistSignalUtils {
  * ```
  */
 const PersistSignalAdapter = new PersistSignalUtils();
+/**
+ * Default file-based implementation of IPersistRiskInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses fixed entity ID "positions" within a per-context PersistBase
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistRiskInstance("my-risk", "binance");
+ * await instance.waitForInit(true);
+ * await instance.writePositionData([["strategy:BTCUSDT", positionData]]);
+ * const positions = await instance.readPositionData();
+ * ```
+ */
+class PersistRiskInstance {
+    /**
+     * Creates new risk positions persistence instance.
+     *
+     * @param riskName - Risk profile identifier
+     * @param exchangeName - Exchange identifier
+     */
+    constructor(riskName, exchangeName) {
+        this.riskName = riskName;
+        this.exchangeName = exchangeName;
+        this._storage = new PersistBase(`${riskName}_${exchangeName}`, `./dump/data/risk/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the persisted positions array using the fixed STORAGE_KEY.
+     *
+     * @returns Promise resolving to positions (empty array if none persisted)
+     */
+    async readPositionData() {
+        if (await this._storage.hasValue(PersistRiskInstance.STORAGE_KEY)) {
+            return await this._storage.readValue(PersistRiskInstance.STORAGE_KEY);
+        }
+        return [];
+    }
+    /**
+     * Writes the positions array using the fixed STORAGE_KEY.
+     *
+     * @param riskRow - Position entries to persist
+     * @returns Promise that resolves when write is complete
+     */
+    async writePositionData(riskRow) {
+        await this._storage.writeValue(PersistRiskInstance.STORAGE_KEY, riskRow);
+    }
+}
+/** Fixed entity key for storing the positions array */
+PersistRiskInstance.STORAGE_KEY = "positions";
+/**
+ * No-op IPersistRiskInstance implementation used by PersistRiskUtils.useDummy().
+ * All reads return empty array, all writes are discarded.
+ */
+class PersistRiskDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistRiskInstanceCtor.
+     */
+    constructor(_riskName, _exchangeName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns empty positions array.
+     * @returns Promise resolving to []
+     */
+    async readPositionData() { return []; }
+    /**
+     * No-op write (discards positions).
+     * @returns Promise that resolves immediately
+     */
+    async writePositionData(_riskRow) { }
+}
 /**
  * Utility class for managing risk active positions persistence.
  *
@@ -1374,40 +1495,36 @@ const PersistSignalAdapter = new PersistSignalUtils();
  */
 class PersistRiskUtils {
     constructor() {
-        this.PersistRiskFactory = PersistBase;
-        this.getRiskStorage = memoize(([riskName, exchangeName]) => `${riskName}:${exchangeName}`, (riskName, exchangeName) => Reflect.construct(this.PersistRiskFactory, [
-            `${riskName}_${exchangeName}`,
-            `./dump/data/risk/`,
-        ]));
         /**
-         * Reads persisted active positions for a risk profile.
-         *
-         * Called by ClientRisk.waitForInit() to restore state.
-         * Returns empty Map if no positions exist.
+         * Constructor used to create per-context risk instances.
+         * Replaceable via usePersistRiskAdapter() / useJson() / useDummy().
+         */
+        this.PersistRiskInstanceCtor = PersistRiskInstance;
+        /**
+         * Memoized factory creating one IPersistRiskInstance per (riskName, exchange) pair.
+         */
+        this.getRiskStorage = memoize(([riskName, exchangeName]) => `${riskName}:${exchangeName}`, (riskName, exchangeName) => Reflect.construct(this.PersistRiskInstanceCtor, [riskName, exchangeName]));
+        /**
+         * Reads persisted active positions for the given risk context.
+         * Lazily initializes the instance on first access.
          *
          * @param riskName - Risk profile identifier
          * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to Map of active positions
+         * @returns Promise resolving to position entries (empty array if none)
          */
         this.readPositionData = async (riskName, exchangeName) => {
             LOGGER_SERVICE$7.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
             const key = `${riskName}:${exchangeName}`;
             const isInitial = !this.getRiskStorage.has(key);
-            const stateStorage = this.getRiskStorage(riskName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            const RISK_STORAGE_KEY = "positions";
-            if (await stateStorage.hasValue(RISK_STORAGE_KEY)) {
-                return await stateStorage.readValue(RISK_STORAGE_KEY);
-            }
-            return [];
+            const instance = this.getRiskStorage(riskName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.readPositionData();
         };
         /**
-         * Writes active positions to disk with atomic file writes.
+         * Writes active positions for the given risk context.
+         * Lazily initializes the instance on first access.
          *
-         * Called by ClientRisk after addSignal/removeSignal to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
-         *
-         * @param positions - Map of active positions
+         * @param riskRow - Position entries to persist
          * @param riskName - Risk profile identifier
          * @param exchangeName - Exchange identifier
          * @returns Promise that resolves when write is complete
@@ -1416,54 +1533,43 @@ class PersistRiskUtils {
             LOGGER_SERVICE$7.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${riskName}:${exchangeName}`;
             const isInitial = !this.getRiskStorage.has(key);
-            const stateStorage = this.getRiskStorage(riskName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            const RISK_STORAGE_KEY = "positions";
-            await stateStorage.writeValue(RISK_STORAGE_KEY, riskRow);
+            const instance = this.getRiskStorage(riskName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.writePositionData(riskRow);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistRiskInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
-     *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistRiskAdapter.usePersistRiskAdapter(RedisPersist);
-     * ```
+     * @param Ctor - Custom IPersistRiskInstance constructor
      */
     usePersistRiskAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
-        this.PersistRiskFactory = Ctor;
+        this.PersistRiskInstanceCtor = Ctor;
+        this.getRiskStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_RISK_UTILS_METHOD_NAME_CLEAR);
         this.getRiskStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistRiskInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistRiskAdapter(PersistBase);
+        this.usePersistRiskAdapter(PersistRiskInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistRiskDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistRiskAdapter(PersistDummy);
+        this.usePersistRiskAdapter(PersistRiskDummyInstance);
     }
 }
 /**
@@ -1483,6 +1589,92 @@ class PersistRiskUtils {
  * ```
  */
 const PersistRiskAdapter = new PersistRiskUtils();
+/**
+ * Default file-based implementation of IPersistScheduleInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses symbol as entity ID within a per-context PersistBase
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistScheduleInstance("BTCUSDT", "my-strategy", "binance");
+ * await instance.waitForInit(true);
+ * await instance.writeScheduleData(scheduledRow);
+ * const restored = await instance.readScheduleData();
+ * ```
+ */
+class PersistScheduleInstance {
+    /**
+     * Creates new scheduled signal persistence instance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     */
+    constructor(symbol, strategyName, exchangeName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this._storage = new PersistBase(`${symbol}_${strategyName}_${exchangeName}`, `./dump/data/schedule/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the persisted scheduled signal using `symbol` as the entity key.
+     *
+     * @returns Promise resolving to scheduled signal or null if not found
+     */
+    async readScheduleData() {
+        if (await this._storage.hasValue(this.symbol)) {
+            return await this._storage.readValue(this.symbol);
+        }
+        return null;
+    }
+    /**
+     * Writes the scheduled signal (or null to clear) using `symbol` as the entity key.
+     *
+     * @param row - Scheduled signal data to persist, or null to clear
+     * @returns Promise that resolves when write is complete
+     */
+    async writeScheduleData(row) {
+        await this._storage.writeValue(this.symbol, row);
+    }
+}
+/**
+ * No-op IPersistScheduleInstance implementation used by PersistScheduleUtils.useDummy().
+ * All reads return null, all writes are discarded.
+ */
+class PersistScheduleDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistScheduleInstanceCtor.
+     */
+    constructor(_symbol, _strategyName, _exchangeName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no persisted scheduled signal).
+     * @returns Promise resolving to null
+     */
+    async readScheduleData() { return null; }
+    /**
+     * No-op write (discards scheduled signal).
+     * @returns Promise that resolves immediately
+     */
+    async writeScheduleData(_row) { }
+}
 /**
  * Utility class for managing scheduled signal persistence.
  *
@@ -1496,40 +1688,37 @@ const PersistRiskAdapter = new PersistRiskUtils();
  */
 class PersistScheduleUtils {
     constructor() {
-        this.PersistScheduleFactory = PersistBase;
-        this.getScheduleStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistScheduleFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/schedule/`,
-        ]));
         /**
-         * Reads persisted scheduled signal data for a symbol and strategy.
-         *
-         * Called by ClientStrategy.waitForInit() to restore scheduled signal state.
-         * Returns null if no scheduled signal exists.
+         * Constructor used to create per-context scheduled signal instances.
+         * Replaceable via usePersistScheduleAdapter() / useJson() / useDummy().
+         */
+        this.PersistScheduleInstanceCtor = PersistScheduleInstance;
+        /**
+         * Memoized factory creating one IPersistScheduleInstance per (symbol, strategy, exchange) triple.
+         */
+        this.getScheduleStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistScheduleInstanceCtor, [symbol, strategyName, exchangeName]));
+        /**
+         * Reads persisted scheduled signal for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to scheduled signal or null
+         * @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);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getScheduleStorage.has(key);
-            const stateStorage = this.getScheduleStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(symbol)) {
-                return await stateStorage.readValue(symbol);
-            }
-            return null;
+            const instance = this.getScheduleStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.readScheduleData();
         };
         /**
-         * Writes scheduled signal data to disk with atomic file writes.
-         *
-         * Called by ClientStrategy.setScheduledSignal() to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Writes scheduled signal (or null to clear) for the given context.
+         * Lazily initializes the instance on first access.
          *
-         * @param scheduledSignalRow - Scheduled signal data (null to clear)
+         * @param scheduledSignalRow - Scheduled signal data to persist, or null to clear
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
@@ -1539,53 +1728,43 @@ class PersistScheduleUtils {
             LOGGER_SERVICE$7.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getScheduleStorage.has(key);
-            const stateStorage = this.getScheduleStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(symbol, scheduledSignalRow);
+            const instance = this.getScheduleStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.writeScheduleData(scheduledSignalRow);
         };
     }
     /**
-     * Registers a custom persistence adapter.
-     *
-     * @param Ctor - Custom PersistBase constructor
+     * Registers a custom IPersistScheduleInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistScheduleAdapter.usePersistScheduleAdapter(RedisPersist);
-     * ```
+     * @param Ctor - Custom IPersistScheduleInstance constructor
      */
     usePersistScheduleAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
-        this.PersistScheduleFactory = Ctor;
+        this.PersistScheduleInstanceCtor = Ctor;
+        this.getScheduleStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_CLEAR);
         this.getScheduleStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistScheduleInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistScheduleAdapter(PersistBase);
+        this.usePersistScheduleAdapter(PersistScheduleInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistScheduleDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistScheduleAdapter(PersistDummy);
+        this.usePersistScheduleAdapter(PersistScheduleDummyInstance);
     }
 }
 /**
@@ -1605,6 +1784,94 @@ class PersistScheduleUtils {
  * ```
  */
 const PersistScheduleAdapter = new PersistScheduleUtils();
+/**
+ * Default file-based implementation of IPersistPartialInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses signalId as entity ID within a per-context PersistBase
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistPartialInstance("BTCUSDT", "my-strategy", "binance");
+ * await instance.waitForInit(true);
+ * await instance.writePartialData(partialData, "signal-id-1");
+ * const restored = await instance.readPartialData("signal-id-1");
+ * ```
+ */
+class PersistPartialInstance {
+    /**
+     * Creates new partial data persistence instance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     */
+    constructor(symbol, strategyName, exchangeName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this._storage = new PersistBase(`${symbol}_${strategyName}_${exchangeName}`, `./dump/data/partial/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the partial data for the given signal using `signalId` as the entity key.
+     *
+     * @param signalId - Signal identifier
+     * @returns Promise resolving to partial data record (empty object if not found)
+     */
+    async readPartialData(signalId) {
+        if (await this._storage.hasValue(signalId)) {
+            return await this._storage.readValue(signalId);
+        }
+        return {};
+    }
+    /**
+     * Writes the partial data for the given signal using `signalId` as the entity key.
+     *
+     * @param data - Partial data record to persist
+     * @param signalId - Signal identifier
+     * @returns Promise that resolves when write is complete
+     */
+    async writePartialData(data, signalId) {
+        await this._storage.writeValue(signalId, data);
+    }
+}
+/**
+ * No-op IPersistPartialInstance implementation used by PersistPartialUtils.useDummy().
+ * All reads return empty object, all writes are discarded.
+ */
+class PersistPartialDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistPartialInstanceCtor.
+     */
+    constructor(_symbol, _strategyName, _exchangeName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns empty partial data record.
+     * @returns Promise resolving to {}
+     */
+    async readPartialData(_signalId) { return {}; }
+    /**
+     * No-op write (discards partial data).
+     * @returns Promise that resolves immediately
+     */
+    async writePartialData(_data, _signalId) { }
+}
 /**
  * Utility class for managing partial profit/loss levels persistence.
  *
@@ -1618,41 +1885,39 @@ const PersistScheduleAdapter = new PersistScheduleUtils();
  */
 class PersistPartialUtils {
     constructor() {
-        this.PersistPartialFactory = PersistBase;
-        this.getPartialStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistPartialFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/partial/`,
-        ]));
         /**
-         * Reads persisted partial data for a symbol and strategy.
-         *
-         * Called by ClientPartial.waitForInit() to restore state.
-         * Returns empty object if no partial data exists.
+         * Constructor used to create per-context partial data instances.
+         * Replaceable via usePersistPartialAdapter() / useJson() / useDummy().
+         */
+        this.PersistPartialInstanceCtor = PersistPartialInstance;
+        /**
+         * Memoized factory creating one IPersistPartialInstance per (symbol, strategy, exchange) triple.
+         * Each signal's partial data is stored under its own signalId within the instance.
+         */
+        this.getPartialStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistPartialInstanceCtor, [symbol, strategyName, exchangeName]));
+        /**
+         * Reads partial data for the given context and signalId.
+         * Lazily initializes the instance on first access.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param signalId - Signal identifier
          * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to partial data record
+         * @returns Promise resolving to partial data record (empty object if none)
          */
         this.readPartialData = async (symbol, strategyName, signalId, exchangeName) => {
             LOGGER_SERVICE$7.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getPartialStorage.has(key);
-            const stateStorage = this.getPartialStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(signalId)) {
-                return await stateStorage.readValue(signalId);
-            }
-            return {};
+            const instance = this.getPartialStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.readPartialData(signalId);
         };
         /**
-         * Writes partial data to disk with atomic file writes.
+         * Writes partial data for the given context and signalId.
+         * Lazily initializes the instance on first access.
          *
-         * Called by ClientPartial after profit/loss level changes to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
-         *
-         * @param partialData - Record of signal IDs to partial data
+         * @param partialData - Partial data record to persist
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param signalId - Signal identifier
@@ -1663,53 +1928,43 @@ class PersistPartialUtils {
             LOGGER_SERVICE$7.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getPartialStorage.has(key);
-            const stateStorage = this.getPartialStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(signalId, partialData);
+            const instance = this.getPartialStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.writePartialData(partialData, signalId);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistPartialInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
-     *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistPartialAdapter.usePersistPartialAdapter(RedisPersist);
-     * ```
+     * @param Ctor - Custom IPersistPartialInstance constructor
      */
     usePersistPartialAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
-        this.PersistPartialFactory = Ctor;
+        this.PersistPartialInstanceCtor = Ctor;
+        this.getPartialStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_CLEAR);
         this.getPartialStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistPartialInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistPartialAdapter(PersistBase);
+        this.usePersistPartialAdapter(PersistPartialInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistPartialDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistPartialAdapter(PersistDummy);
+        this.usePersistPartialAdapter(PersistPartialDummyInstance);
     }
 }
 /**
@@ -1729,11 +1984,99 @@ class PersistPartialUtils {
  * ```
  */
 const PersistPartialAdapter = new PersistPartialUtils();
+/**
+ * Default file-based implementation of IPersistBreakevenInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses signalId as entity ID within a per-context PersistBase
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistBreakevenInstance("BTCUSDT", "my-strategy", "binance");
+ * await instance.waitForInit(true);
+ * await instance.writeBreakevenData(breakevenData, "signal-id-1");
+ * const restored = await instance.readBreakevenData("signal-id-1");
+ * ```
+ */
+class PersistBreakevenInstance {
+    /**
+     * Creates new breakeven persistence instance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     */
+    constructor(symbol, strategyName, exchangeName) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this._storage = new PersistBase(`${symbol}_${strategyName}_${exchangeName}`, `./dump/data/breakeven/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the breakeven data for the given signal using `signalId` as the entity key.
+     *
+     * @param signalId - Signal identifier
+     * @returns Promise resolving to breakeven data record (empty object if not found)
+     */
+    async readBreakevenData(signalId) {
+        if (await this._storage.hasValue(signalId)) {
+            return await this._storage.readValue(signalId);
+        }
+        return {};
+    }
+    /**
+     * Writes the breakeven data for the given signal using `signalId` as the entity key.
+     *
+     * @param data - Breakeven data record to persist
+     * @param signalId - Signal identifier
+     * @returns Promise that resolves when write is complete
+     */
+    async writeBreakevenData(data, signalId) {
+        await this._storage.writeValue(signalId, data);
+    }
+}
+/**
+ * No-op IPersistBreakevenInstance implementation used by PersistBreakevenUtils.useDummy().
+ * All reads return empty object, all writes are discarded.
+ */
+class PersistBreakevenDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistBreakevenInstanceCtor.
+     */
+    constructor(_symbol, _strategyName, _exchangeName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns empty breakeven data record.
+     * @returns Promise resolving to {}
+     */
+    async readBreakevenData(_signalId) { return {}; }
+    /**
+     * No-op write (discards breakeven data).
+     * @returns Promise that resolves immediately
+     */
+    async writeBreakevenData(_data, _signalId) { }
+}
 /**
  * Persistence utility class for breakeven state management.
  *
  * Handles reading and writing breakeven state to disk.
- * Uses memoized PersistBase instances per symbol-strategy pair.
+ * Uses memoized PersistBreakevenInstance instances per symbol-strategy pair.
  *
  * Features:
  * - Atomic file writes via PersistBase.writeValue()
@@ -1763,53 +2106,36 @@ const PersistPartialAdapter = new PersistPartialUtils();
 class PersistBreakevenUtils {
     constructor() {
         /**
-         * Factory for creating PersistBase instances.
-         * Can be replaced via usePersistBreakevenAdapter().
+         * Constructor used to create per-context breakeven instances.
+         * Replaceable via usePersistBreakevenAdapter() / useJson() / useDummy().
          */
-        this.PersistBreakevenFactory = PersistBase;
+        this.PersistBreakevenInstanceCtor = PersistBreakevenInstance;
         /**
-         * Memoized storage factory for breakeven data.
-         * Creates one PersistBase instance per symbol-strategy-exchange combination.
-         * Key format: "symbol:strategyName:exchangeName"
-         *
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param exchangeName - Exchange identifier
-         * @returns PersistBase instance for this symbol-strategy-exchange combination
+         * Memoized factory creating one IPersistBreakevenInstance per (symbol, strategy, exchange) triple.
+         * Each signal's breakeven data is stored under its own signalId within the instance.
          */
-        this.getBreakevenStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistBreakevenFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/breakeven/`,
-        ]));
+        this.getBreakevenStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistBreakevenInstanceCtor, [symbol, strategyName, exchangeName]));
         /**
-         * Reads persisted breakeven data for a symbol and strategy.
-         *
-         * Called by ClientBreakeven.waitForInit() to restore state.
-         * Returns empty object if no breakeven data exists.
+         * Reads breakeven data for the given context and signalId.
+         * Lazily initializes the instance on first access.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param signalId - Signal identifier
          * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to breakeven data record
+         * @returns Promise resolving to breakeven data record (empty object if none)
          */
         this.readBreakevenData = async (symbol, strategyName, signalId, exchangeName) => {
             LOGGER_SERVICE$7.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getBreakevenStorage.has(key);
-            const stateStorage = this.getBreakevenStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(signalId)) {
-                return await stateStorage.readValue(signalId);
-            }
-            return {};
+            const instance = this.getBreakevenStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.readBreakevenData(signalId);
         };
         /**
-         * Writes breakeven data to disk.
-         *
-         * Called by ClientBreakeven._persistState() after state changes.
-         * Creates directory and file if they don't exist.
-         * Uses atomic writes to prevent data corruption.
+         * Writes breakeven data for the given context and signalId.
+         * Lazily initializes the instance on first access.
          *
          * @param breakevenData - Breakeven data record to persist
          * @param symbol - Trading pair symbol
@@ -1822,53 +2148,43 @@ class PersistBreakevenUtils {
             LOGGER_SERVICE$7.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
             const isInitial = !this.getBreakevenStorage.has(key);
-            const stateStorage = this.getBreakevenStorage(symbol, strategyName, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(signalId, breakevenData);
+            const instance = this.getBreakevenStorage(symbol, strategyName, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.writeBreakevenData(breakevenData, signalId);
         };
     }
     /**
-     * Registers a custom persistence adapter.
-     *
-     * @param Ctor - Custom PersistBase constructor
+     * Registers a custom IPersistBreakevenInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
-     * ```
+     * @param Ctor - Custom IPersistBreakevenInstance constructor
      */
     usePersistBreakevenAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
-        this.PersistBreakevenFactory = Ctor;
+        this.PersistBreakevenInstanceCtor = Ctor;
+        this.getBreakevenStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_CLEAR);
         this.getBreakevenStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistBreakevenInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistBreakevenAdapter(PersistBase);
+        this.usePersistBreakevenAdapter(PersistBreakevenInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistBreakevenDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistBreakevenAdapter(PersistDummy);
+        this.usePersistBreakevenAdapter(PersistBreakevenDummyInstance);
     }
 }
 /**
@@ -1888,6 +2204,140 @@ class PersistBreakevenUtils {
  * ```
  */
 const PersistBreakevenAdapter = new PersistBreakevenUtils();
+/**
+ * Default file-based implementation of IPersistCandleInstance.
+ *
+ * Features:
+ * - Each candle stored as a separate JSON file keyed by its timestamp
+ * - Read returns null on any missing timestamp (cache miss → refetch)
+ * - Write skips incomplete candles (closeTime > now) and existing keys
+ * - Invalid cached candles emit warnings via errorEmitter and treated as miss
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistCandleInstance("BTCUSDT", "1m", "binance");
+ * await instance.waitForInit(true);
+ * await instance.writeCandlesData(candles);
+ * const cached = await instance.readCandlesData(100, since, until);
+ * ```
+ */
+class PersistCandleInstance {
+    /**
+     * Creates new candle cache persistence instance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param interval - Candle interval (1m, 5m, 1h, etc.)
+     * @param exchangeName - Exchange identifier
+     */
+    constructor(symbol, interval, exchangeName) {
+        this.symbol = symbol;
+        this.interval = interval;
+        this.exchangeName = exchangeName;
+        this._storage = new PersistBase(`${exchangeName}/${symbol}/${interval}`, `./dump/data/candle/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads cached candles for the requested window.
+     * Computes expected timestamps (sinceTimestamp + i * stepMs) and reads each
+     * by timestamp key. Returns null on ANY missing timestamp (cache miss).
+     * Invalid cached candles emit a warning via errorEmitter and are treated as miss.
+     *
+     * @param limit - Number of candles requested
+     * @param sinceTimestamp - Aligned start timestamp (openTime of first candle)
+     * @param _untilTimestamp - Reserved for API compatibility, unused
+     * @returns Promise resolving to candles in order, or null on cache miss
+     */
+    async readCandlesData(limit, sinceTimestamp, _untilTimestamp) {
+        const stepMs = INTERVAL_MINUTES$9[this.interval] * MS_PER_MINUTE$7;
+        const cachedCandles = [];
+        for (let i = 0; i < limit; i++) {
+            const expectedTimestamp = sinceTimestamp + i * stepMs;
+            const timestampKey = String(expectedTimestamp);
+            if (await not(this._storage.hasValue(timestampKey))) {
+                return null;
+            }
+            try {
+                const candle = await this._storage.readValue(timestampKey);
+                cachedCandles.push(candle);
+            }
+            catch (error) {
+                const message = `PersistCandleInstance.readCandlesData found invalid candle symbol=${this.symbol} interval=${this.interval} timestamp=${expectedTimestamp}`;
+                const payload = {
+                    error: errorData(error),
+                    message: getErrorMessage(error),
+                };
+                LOGGER_SERVICE$7.warn(message, payload);
+                console.warn(message, payload);
+                errorEmitter.next(error);
+                return null;
+            }
+        }
+        return cachedCandles;
+    }
+    /**
+     * Writes candles to cache.
+     * Skips incomplete candles (closeTime > now) and existing keys to keep
+     * the cache append-only for fully closed candles.
+     *
+     * @param candles - Array of candle data to cache
+     * @returns Promise that resolves when all writes are complete
+     */
+    async writeCandlesData(candles) {
+        const stepMs = INTERVAL_MINUTES$9[this.interval] * MS_PER_MINUTE$7;
+        const now = Date.now();
+        for (const candle of candles) {
+            const candleCloseTime = candle.timestamp + stepMs;
+            if (candleCloseTime > now) {
+                LOGGER_SERVICE$7.debug("PersistCandleInstance.writeCandlesData: skipping incomplete candle", {
+                    symbol: this.symbol,
+                    interval: this.interval,
+                    exchangeName: this.exchangeName,
+                    timestamp: candle.timestamp,
+                    closeTime: candleCloseTime,
+                    now,
+                });
+                continue;
+            }
+            if (await not(this._storage.hasValue(String(candle.timestamp)))) {
+                await this._storage.writeValue(String(candle.timestamp), candle);
+            }
+        }
+    }
+}
+/**
+ * No-op IPersistCandleInstance implementation used by PersistCandleUtils.useDummy().
+ * Always returns null on read (forces refetch), discards writes.
+ */
+class PersistCandleDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistCandleInstanceCtor.
+     */
+    constructor(_symbol, _interval, _exchangeName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (forces refetch via cache miss).
+     * @returns Promise resolving to null
+     */
+    async readCandlesData(_limit, _since, _until) { return null; }
+    /**
+     * No-op write (discards candles).
+     * @returns Promise that resolves immediately
+     */
+    async writeCandlesData(_candles) { }
+}
 /**
  * Utility class for managing candles cache persistence.
  *
@@ -1901,30 +2351,28 @@ const PersistBreakevenAdapter = new PersistBreakevenUtils();
  */
 class PersistCandleUtils {
     constructor() {
-        this.PersistCandlesFactory = PersistBase;
-        this.getCandlesStorage = memoize(([symbol, interval, exchangeName]) => `${symbol}:${interval}:${exchangeName}`, (symbol, interval, exchangeName) => Reflect.construct(this.PersistCandlesFactory, [
-            `${exchangeName}/${symbol}/${interval}`,
-            `./dump/data/candle/`,
-        ]));
         /**
-         * Reads cached candles for a specific exchange, symbol, and interval.
-         * Returns candles only if cache contains ALL requested candles.
-         *
-         * Algorithm (matches ClientExchange.ts logic):
-         * 1. Calculate expected timestamps: sinceTimestamp, sinceTimestamp + stepMs, ..., sinceTimestamp + (limit-1) * stepMs
-         * 2. Try to read each expected candle by timestamp key
-         * 3. If ANY candle is missing, return null (cache miss)
-         * 4. If all candles found, return them in order
+         * Constructor used to create per-context candle cache instances.
+         * Replaceable via usePersistCandleAdapter() / useJson() / useDummy().
+         */
+        this.PersistCandleInstanceCtor = PersistCandleInstance;
+        /**
+         * Memoized factory creating one IPersistCandleInstance per (symbol, interval, exchange) triple.
+         */
+        this.getCandlesStorage = memoize(([symbol, interval, exchangeName]) => `${symbol}:${interval}:${exchangeName}`, (symbol, interval, exchangeName) => Reflect.construct(this.PersistCandleInstanceCtor, [symbol, interval, exchangeName]));
+        /**
+         * Reads cached candles for the given context and time window.
+         * Lazily initializes the instance on first access.
          *
          * @param symbol - Trading pair symbol
          * @param interval - Candle interval
          * @param exchangeName - Exchange identifier
          * @param limit - Number of candles requested
          * @param sinceTimestamp - Aligned start timestamp (openTime of first candle)
-         * @param _untilTimestamp - Unused, kept for API compatibility
-         * @returns Promise resolving to array of candles or null if cache is incomplete
+         * @param untilTimestamp - Reserved for API compatibility
+         * @returns Promise resolving to candles in order, or null on cache miss
          */
-        this.readCandlesData = async (symbol, interval, exchangeName, limit, sinceTimestamp, _untilTimestamp) => {
+        this.readCandlesData = async (symbol, interval, exchangeName, limit, sinceTimestamp, untilTimestamp) => {
             LOGGER_SERVICE$7.info("PersistCandleUtils.readCandlesData", {
                 symbol,
                 interval,
@@ -1934,47 +2382,15 @@ class PersistCandleUtils {
             });
             const key = `${symbol}:${interval}:${exchangeName}`;
             const isInitial = !this.getCandlesStorage.has(key);
-            const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            const stepMs = INTERVAL_MINUTES$9[interval] * MS_PER_MINUTE$7;
-            // Calculate expected timestamps and fetch each candle directly
-            const cachedCandles = [];
-            for (let i = 0; i < limit; i++) {
-                const expectedTimestamp = sinceTimestamp + i * stepMs;
-                const timestampKey = String(expectedTimestamp);
-                if (await not(stateStorage.hasValue(timestampKey))) {
-                    // Cache miss - candle not found
-                    return null;
-                }
-                try {
-                    const candle = await stateStorage.readValue(timestampKey);
-                    cachedCandles.push(candle);
-                }
-                catch (error) {
-                    // Invalid candle in cache - treat as cache miss
-                    const message = `PersistCandleUtils.readCandlesData found invalid candle symbol=${symbol} interval=${interval} timestamp=${expectedTimestamp}`;
-                    const payload = {
-                        error: errorData(error),
-                        message: getErrorMessage(error),
-                    };
-                    LOGGER_SERVICE$7.warn(message, payload);
-                    console.warn(message, payload);
-                    errorEmitter.next(error);
-                    return null;
-                }
-            }
-            return cachedCandles;
+            const instance = this.getCandlesStorage(symbol, interval, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.readCandlesData(limit, sinceTimestamp, untilTimestamp);
         };
         /**
-         * Writes candles to cache with atomic file writes.
-         * Each candle is stored as a separate JSON file named by its timestamp.
+         * Writes candles to cache for the given context.
+         * Lazily initializes the instance on first access.
          *
-         * The candles passed to this function should be validated candles from the adapter:
-         * - First candle.timestamp equals aligned sinceTimestamp (openTime)
-         * - Exact number of candles as requested
-         * - All candles are fully closed (timestamp + stepMs < untilTimestamp)
-         *
-         * @param candles - Array of candle data to cache (validated by the caller)
+         * @param candles - Array of candle data to cache
          * @param symbol - Trading pair symbol
          * @param interval - Candle interval
          * @param exchangeName - Exchange identifier
@@ -1989,66 +2405,43 @@ class PersistCandleUtils {
             });
             const key = `${symbol}:${interval}:${exchangeName}`;
             const isInitial = !this.getCandlesStorage.has(key);
-            const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
-            await stateStorage.waitForInit(isInitial);
-            // Calculate step in milliseconds to determine candle close time
-            const stepMs = INTERVAL_MINUTES$9[interval] * MS_PER_MINUTE$7;
-            const now = Date.now();
-            // Write each candle as a separate file, skipping incomplete candles
-            for (const candle of candles) {
-                // Skip incomplete candles: candle is complete when closeTime <= now
-                // closeTime = timestamp + stepMs
-                const candleCloseTime = candle.timestamp + stepMs;
-                if (candleCloseTime > now) {
-                    LOGGER_SERVICE$7.debug("PersistCandleUtils.writeCandlesData: skipping incomplete candle", {
-                        symbol,
-                        interval,
-                        exchangeName,
-                        timestamp: candle.timestamp,
-                        closeTime: candleCloseTime,
-                        now,
-                    });
-                    continue;
-                }
-                if (await not(stateStorage.hasValue(String(candle.timestamp)))) {
-                    await stateStorage.writeValue(String(candle.timestamp), candle);
-                }
-            }
+            const instance = this.getCandlesStorage(symbol, interval, exchangeName);
+            await instance.waitForInit(isInitial);
+            return instance.writeCandlesData(candles);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistCandleInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistCandleInstance constructor
      */
     usePersistCandleAdapter(Ctor) {
         LOGGER_SERVICE$7.info("PersistCandleUtils.usePersistCandleAdapter");
-        this.PersistCandlesFactory = Ctor;
+        this.PersistCandleInstanceCtor = Ctor;
+        this.getCandlesStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_CANDLE_UTILS_METHOD_NAME_CLEAR);
         this.getCandlesStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistCandleInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log("PersistCandleUtils.useJson");
-        this.usePersistCandleAdapter(PersistBase);
+        this.usePersistCandleAdapter(PersistCandleInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistCandleDummyInstance (always returns null on read, discards writes).
      */
     useDummy() {
         LOGGER_SERVICE$7.log("PersistCandleUtils.useDummy");
-        this.usePersistCandleAdapter(PersistDummy);
+        this.usePersistCandleAdapter(PersistCandleDummyInstance);
     }
 }
 /**
@@ -2067,6 +2460,92 @@ class PersistCandleUtils {
  * ```
  */
 const PersistCandleAdapter = new PersistCandleUtils();
+/**
+ * Default file-based implementation of IPersistStorageInstance.
+ *
+ * Features:
+ * - Each signal stored as separate JSON file keyed by signal.id
+ * - Read iterates all keys via PersistBase.keys()
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistStorageInstance(false);
+ * await instance.waitForInit(true);
+ * await instance.writeStorageData(signals);
+ * const all = await instance.readStorageData();
+ * ```
+ */
+class PersistStorageInstance {
+    /**
+     * Creates new signal storage persistence instance.
+     *
+     * @param backtest - True for backtest mode storage, false for live mode
+     */
+    constructor(backtest) {
+        this.backtest = backtest;
+        this._storage = new PersistBase(backtest ? `backtest` : `live`, `./dump/data/storage/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads all persisted signals by iterating storage keys.
+     *
+     * @returns Promise resolving to array of signal entries
+     */
+    async readStorageData() {
+        const signals = [];
+        for await (const signalId of this._storage.keys()) {
+            const signal = await this._storage.readValue(signalId);
+            signals.push(signal);
+        }
+        return signals;
+    }
+    /**
+     * Writes each signal as a separate entity keyed by `signal.id`.
+     *
+     * @param signals - Signal entries to persist
+     * @returns Promise that resolves when all writes are complete
+     */
+    async writeStorageData(signals) {
+        for (const signal of signals) {
+            await this._storage.writeValue(signal.id, signal);
+        }
+    }
+}
+/**
+ * No-op IPersistStorageInstance implementation used by PersistStorageUtils.useDummy().
+ * All reads return empty array, all writes are discarded.
+ */
+class PersistStorageDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistStorageInstanceCtor.
+     */
+    constructor(_backtest) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns empty signals array.
+     * @returns Promise resolving to []
+     */
+    async readStorageData() { return []; }
+    /**
+     * No-op write (discards signals).
+     * @returns Promise that resolves immediately
+     */
+    async writeStorageData(_signals) { }
+}
 /**
  * Utility class for managing signal storage persistence.
  *
@@ -2081,89 +2560,80 @@ const PersistCandleAdapter = new PersistCandleUtils();
  */
 class PersistStorageUtils {
     constructor() {
-        this.PersistStorageFactory = PersistBase;
-        this.getStorage = memoize(([backtest]) => backtest ? `backtest` : `live`, (backtest) => Reflect.construct(this.PersistStorageFactory, [
-            backtest ? `backtest` : `live`,
-            `./dump/data/storage/`,
-        ]));
         /**
-         * Reads persisted signals data.
-         *
-         * Called by StorageLiveUtils/StorageBacktestUtils.waitForInit() to restore state.
-         * Uses keys() from PersistBase to iterate over all stored signals.
-         * Returns empty array if no signals exist.
+         * Constructor used to create per-mode signal storage instances.
+         * Replaceable via usePersistStorageAdapter() / useJson() / useDummy().
+         */
+        this.PersistStorageInstanceCtor = PersistStorageInstance;
+        /**
+         * Memoized factory creating one IPersistStorageInstance per mode (backtest/live).
+         * Key: "backtest" or "live".
+         */
+        this.getStorage = memoize(([backtest]) => backtest ? `backtest` : `live`, (backtest) => Reflect.construct(this.PersistStorageInstanceCtor, [backtest]));
+        /**
+         * Reads all persisted signals for the given mode.
+         * Lazily initializes the instance on first access.
          *
-         * @param backtest - If true, reads from backtest storage; otherwise from live storage
+         * @param backtest - True for backtest mode storage, false for live mode
          * @returns Promise resolving to array of signal entries
          */
         this.readStorageData = async (backtest) => {
             LOGGER_SERVICE$7.info(PERSIST_STORAGE_UTILS_METHOD_NAME_READ_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getStorage.has(key);
-            const stateStorage = this.getStorage(backtest);
-            await stateStorage.waitForInit(isInitial);
-            const signals = [];
-            for await (const signalId of stateStorage.keys()) {
-                const signal = await stateStorage.readValue(signalId);
-                signals.push(signal);
-            }
-            return signals;
+            const instance = this.getStorage(backtest);
+            await instance.waitForInit(isInitial);
+            return instance.readStorageData();
         };
         /**
-         * Writes signal data to disk with atomic file writes.
-         *
-         * Called by StorageLiveUtils/StorageBacktestUtils after signal changes to persist state.
-         * Uses signal.id as the storage key for individual file storage.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Writes signals for the given mode.
+         * Lazily initializes the instance on first access.
          *
          * @param signalData - Signal entries to persist
-         * @param backtest - If true, writes to backtest storage; otherwise to live storage
+         * @param backtest - True for backtest mode storage, false for live mode
          * @returns Promise that resolves when write is complete
          */
         this.writeStorageData = async (signalData, backtest) => {
             LOGGER_SERVICE$7.info(PERSIST_STORAGE_UTILS_METHOD_NAME_WRITE_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getStorage.has(key);
-            const stateStorage = this.getStorage(backtest);
-            await stateStorage.waitForInit(isInitial);
-            for (const signal of signalData) {
-                await stateStorage.writeValue(signal.id, signal);
-            }
+            const instance = this.getStorage(backtest);
+            await instance.waitForInit(isInitial);
+            return instance.writeStorageData(signalData);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistStorageInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistStorageInstance constructor
      */
     usePersistStorageAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_PERSIST_STORAGE_ADAPTER);
-        this.PersistStorageFactory = Ctor;
+        this.PersistStorageInstanceCtor = Ctor;
+        this.getStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_STORAGE_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistStorageInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistStorageAdapter(PersistBase);
+        this.usePersistStorageAdapter(PersistStorageInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistStorageDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_STORAGE_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistStorageAdapter(PersistDummy);
+        this.usePersistStorageAdapter(PersistStorageDummyInstance);
     }
 }
 /**
@@ -2171,6 +2641,92 @@ class PersistStorageUtils {
  * Used by SignalLiveUtils for signal storage persistence.
  */
 const PersistStorageAdapter = new PersistStorageUtils();
+/**
+ * Default file-based implementation of IPersistNotificationInstance.
+ *
+ * Features:
+ * - Each notification stored as separate JSON file keyed by id
+ * - Read iterates all keys via PersistBase.keys()
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistNotificationInstance(false);
+ * await instance.waitForInit(true);
+ * await instance.writeNotificationData(notifications);
+ * const all = await instance.readNotificationData();
+ * ```
+ */
+class PersistNotificationInstance {
+    /**
+     * Creates new notification persistence instance.
+     *
+     * @param backtest - True for backtest mode storage, false for live mode
+     */
+    constructor(backtest) {
+        this.backtest = backtest;
+        this._storage = new PersistBase(backtest ? `backtest` : `live`, `./dump/data/notification/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads all persisted notifications by iterating storage keys.
+     *
+     * @returns Promise resolving to array of notification entries
+     */
+    async readNotificationData() {
+        const notifications = [];
+        for await (const notificationId of this._storage.keys()) {
+            const notification = await this._storage.readValue(notificationId);
+            notifications.push(notification);
+        }
+        return notifications;
+    }
+    /**
+     * Writes each notification as a separate entity keyed by `notification.id`.
+     *
+     * @param notifications - Notification entries to persist
+     * @returns Promise that resolves when all writes are complete
+     */
+    async writeNotificationData(notifications) {
+        for (const notification of notifications) {
+            await this._storage.writeValue(notification.id, notification);
+        }
+    }
+}
+/**
+ * No-op IPersistNotificationInstance implementation used by PersistNotificationUtils.useDummy().
+ * All reads return empty array, all writes are discarded.
+ */
+class PersistNotificationDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistNotificationInstanceCtor.
+     */
+    constructor(_backtest) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns empty notifications array.
+     * @returns Promise resolving to []
+     */
+    async readNotificationData() { return []; }
+    /**
+     * No-op write (discards notifications).
+     * @returns Promise that resolves immediately
+     */
+    async writeNotificationData(_notifications) { }
+}
 /**
  * Utility class for managing notification persistence.
  *
@@ -2185,89 +2741,81 @@ const PersistStorageAdapter = new PersistStorageUtils();
  */
 class PersistNotificationUtils {
     constructor() {
-        this.PersistNotificationFactory = PersistBase;
-        this.getNotificationStorage = memoize(([backtest]) => backtest ? `backtest` : `live`, (backtest) => Reflect.construct(this.PersistNotificationFactory, [
-            backtest ? `backtest` : `live`,
-            `./dump/data/notification/`,
-        ]));
         /**
-         * Reads persisted notifications data.
-         *
-         * Called by NotificationPersistLiveUtils/NotificationPersistBacktestUtils.waitForInit() to restore state.
-         * Uses keys() from PersistBase to iterate over all stored notifications.
-         * Returns empty array if no notifications exist.
+         * Constructor used to create per-mode notification instances.
+         * Replaceable via usePersistNotificationAdapter() / useJson() / useDummy().
+         */
+        this.PersistNotificationInstanceCtor = PersistNotificationInstance;
+        /**
+         * Memoized factory creating one IPersistNotificationInstance per mode (backtest/live).
+         * Key: "backtest" or "live".
+         */
+        this.getNotificationStorage = memoize(([backtest]) => backtest ? `backtest` : `live`, (backtest) => Reflect.construct(this.PersistNotificationInstanceCtor, [backtest]));
+        /**
+         * Reads persisted notifications for the given mode.
+         * Lazily initializes the instance on first access.
          *
-         * @param backtest - If true, reads from backtest storage; otherwise from live storage
+         * @param backtest - True for backtest mode storage, false for live mode
          * @returns Promise resolving to array of notification entries
          */
         this.readNotificationData = async (backtest) => {
             LOGGER_SERVICE$7.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_READ_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getNotificationStorage.has(key);
-            const stateStorage = this.getNotificationStorage(backtest);
-            await stateStorage.waitForInit(isInitial);
-            const notifications = [];
-            for await (const notificationId of stateStorage.keys()) {
-                const notification = await stateStorage.readValue(notificationId);
-                notifications.push(notification);
-            }
-            return notifications;
+            const instance = this.getNotificationStorage(backtest);
+            await instance.waitForInit(isInitial);
+            return instance.readNotificationData();
         };
         /**
-         * Writes notification data to disk with atomic file writes.
-         *
-         * Called by NotificationPersistLiveUtils/NotificationPersistBacktestUtils after notification changes to persist state.
-         * Uses notification.id as the storage key for individual file storage.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Writes notifications for the given mode.
+         * Lazily initializes the instance on first access.
          *
          * @param notificationData - Notification entries to persist
-         * @param backtest - If true, writes to backtest storage; otherwise to live storage
+         * @param backtest - True for backtest mode storage, false for live mode
          * @returns Promise that resolves when write is complete
          */
         this.writeNotificationData = async (notificationData, backtest) => {
             LOGGER_SERVICE$7.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_WRITE_DATA);
             const key = backtest ? `backtest` : `live`;
             const isInitial = !this.getNotificationStorage.has(key);
-            const stateStorage = this.getNotificationStorage(backtest);
-            await stateStorage.waitForInit(isInitial);
-            for (const notification of notificationData) {
-                await stateStorage.writeValue(notification.id, notification);
-            }
+            const instance = this.getNotificationStorage(backtest);
+            await instance.waitForInit(isInitial);
+            return instance.writeNotificationData(notificationData);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistNotificationInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistNotificationInstance constructor
      */
     usePersistNotificationAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_PERSIST_NOTIFICATION_ADAPTER);
-        this.PersistNotificationFactory = Ctor;
+        this.PersistNotificationInstanceCtor = Ctor;
+        this.getNotificationStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations so new
+     * instances are created with the updated base path.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_CLEAR);
         this.getNotificationStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistNotificationInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistNotificationAdapter(PersistBase);
+        this.usePersistNotificationAdapter(PersistNotificationInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistNotificationDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_NOTIFICATION_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistNotificationAdapter(PersistDummy);
+        this.usePersistNotificationAdapter(PersistNotificationDummyInstance);
     }
 }
 /**
@@ -2275,11 +2823,95 @@ class PersistNotificationUtils {
  * Used by NotificationPersistLiveUtils/NotificationPersistBacktestUtils for notification persistence.
  */
 const PersistNotificationAdapter = new PersistNotificationUtils();
+/**
+ * Default file-based implementation of IPersistLogInstance.
+ *
+ * Features:
+ * - Each log entry stored as separate JSON file keyed by entry.id
+ * - Read iterates all keys via PersistBase.keys()
+ * - Append-only: existing keys are skipped on write
+ * - Crash-safe via atomic writes
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistLogInstance();
+ * await instance.waitForInit(true);
+ * await instance.writeLogData(entries);
+ * const all = await instance.readLogData();
+ * ```
+ */
+class PersistLogInstance {
+    /**
+     * Creates new log persistence instance.
+     * No context parameters — there is a single global log storage.
+     */
+    constructor() {
+        this._storage = new PersistBase(`log`, `./dump/data/log/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads all persisted log entries by iterating storage keys.
+     *
+     * @returns Promise resolving to array of log entries
+     */
+    async readLogData() {
+        const entries = [];
+        for await (const entryId of this._storage.keys()) {
+            const entry = await this._storage.readValue(entryId);
+            entries.push(entry);
+        }
+        return entries;
+    }
+    /**
+     * Writes log entries append-only — skips entries whose id already exists
+     * so the log file is never overwritten.
+     *
+     * @param logData - Log entries to persist
+     * @returns Promise that resolves when all writes are complete
+     */
+    async writeLogData(logData) {
+        for (const entry of logData) {
+            if (await this._storage.hasValue(entry.id)) {
+                continue;
+            }
+            await this._storage.writeValue(entry.id, entry);
+        }
+    }
+}
+/**
+ * No-op IPersistLogInstance implementation used by PersistLogUtils.useDummy().
+ * All reads return empty array, all writes are discarded.
+ */
+class PersistLogDummyInstance {
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns empty log entries array.
+     * @returns Promise resolving to []
+     */
+    async readLogData() { return []; }
+    /**
+     * No-op write (discards log entries).
+     * @returns Promise that resolves immediately
+     */
+    async writeLogData(_entries) { }
+}
 /**
  * Utility class for managing log entry persistence.
  *
  * Features:
- * - Memoized storage instance
+ * - Cached storage instance
  * - Custom adapter support
  * - Atomic read/write operations for LogData
  * - Each log entry stored as separate file keyed by id
@@ -2289,94 +2921,87 @@ const PersistNotificationAdapter = new PersistNotificationUtils();
  */
 class PersistLogUtils {
     constructor() {
-        this.PersistLogFactory = PersistBase;
-        this._logStorage = null;
         /**
-         * Reads persisted log entries.
-         *
-         * Called by LogPersistUtils.waitForInit() to restore state.
-         * Uses keys() from PersistBase to iterate over all stored entries.
-         * Returns empty array if no entries exist.
+         * Constructor used to create the global log instance.
+         * Replaceable via usePersistLogAdapter() / useJson() / useDummy().
+         */
+        this.PersistLogInstanceCtor = PersistLogInstance;
+        /**
+         * Cached singleton log instance. Lazily created on first access.
+         * Reset to null by clear() and usePersistLogAdapter().
+         */
+        this._logInstance = null;
+        /**
+         * Reads all persisted log entries.
+         * Lazily initializes the instance on first access.
          *
          * @returns Promise resolving to array of log entries
          */
         this.readLogData = async () => {
             LOGGER_SERVICE$7.info(PERSIST_LOG_UTILS_METHOD_NAME_READ_DATA);
-            const isInitial = !this._logStorage;
-            const stateStorage = this.getLogStorage();
-            await stateStorage.waitForInit(isInitial);
-            const entries = [];
-            for await (const entryId of stateStorage.keys()) {
-                const entry = await stateStorage.readValue(entryId);
-                entries.push(entry);
-            }
-            return entries;
+            const isInitial = !this._logInstance;
+            const instance = this.getLogInstance();
+            await instance.waitForInit(isInitial);
+            return instance.readLogData();
         };
         /**
-         * Writes log entries to disk with atomic file writes.
-         *
-         * Called by LogPersistUtils after each log call to persist state.
-         * Uses entry.id as the storage key for individual file storage.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Writes log entries (append-only — duplicates by id are skipped).
+         * Lazily initializes the instance on first access.
          *
          * @param logData - Log entries to persist
          * @returns Promise that resolves when write is complete
          */
         this.writeLogData = async (logData) => {
             LOGGER_SERVICE$7.info(PERSIST_LOG_UTILS_METHOD_NAME_WRITE_DATA);
-            const isInitial = !this._logStorage;
-            const stateStorage = this.getLogStorage();
-            await stateStorage.waitForInit(isInitial);
-            for (const entry of logData) {
-                if (await stateStorage.hasValue(entry.id)) {
-                    continue;
-                }
-                await stateStorage.writeValue(entry.id, entry);
-            }
+            const isInitial = !this._logInstance;
+            const instance = this.getLogInstance();
+            await instance.waitForInit(isInitial);
+            return instance.writeLogData(logData);
         };
     }
-    getLogStorage() {
-        if (!this._logStorage) {
-            this._logStorage = Reflect.construct(this.PersistLogFactory, [
-                `log`,
-                `./dump/data/log/`,
-            ]);
+    /**
+     * Returns the cached log instance, creating it on first access.
+     *
+     * @returns The IPersistLogInstance singleton
+     */
+    getLogInstance() {
+        if (!this._logInstance) {
+            this._logInstance = Reflect.construct(this.PersistLogInstanceCtor, []);
         }
-        return this._logStorage;
+        return this._logInstance;
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistLogInstance constructor.
+     * Drops the cached instance so the next access uses the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistLogInstance constructor
      */
     usePersistLogAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_LOG_UTILS_METHOD_NAME_USE_PERSIST_LOG_ADAPTER);
-        this.PersistLogFactory = Ctor;
+        this.PersistLogInstanceCtor = Ctor;
+        this._logInstance = null;
     }
     /**
-     * Clears the cached storage instance.
-     * Call this when process.cwd() changes between strategy iterations
-     * so a new storage instance is created with the updated base path.
+     * Drops the cached log instance.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_LOG_UTILS_METHOD_NAME_CLEAR);
-        this._logStorage = null;
+        this._logInstance = null;
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistLogInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistLogAdapter(PersistBase);
+        this.usePersistLogAdapter(PersistLogInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistLogDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_LOG_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistLogAdapter(PersistDummy);
+        this.usePersistLogAdapter(PersistLogDummyInstance);
     }
 }
 /**
@@ -2384,6 +3009,128 @@ class PersistLogUtils {
  * Used by LogPersistUtils for log entry persistence.
  */
 const PersistLogAdapter = new PersistLogUtils();
+/**
+ * Default file-based implementation of IPersistMeasureInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Soft delete via `removed: true` flag
+ * - listMeasureData filters out removed entries
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistMeasureInstance("my-bucket");
+ * await instance.waitForInit(true);
+ * await instance.writeMeasureData({ id: "x", data: {}, removed: false }, "key1");
+ * const data = await instance.readMeasureData("key1");
+ * await instance.removeMeasureData("key1");
+ * ```
+ */
+class PersistMeasureInstance {
+    /**
+     * Creates new measure cache persistence instance.
+     *
+     * @param bucket - Cache bucket identifier
+     */
+    constructor(bucket) {
+        this.bucket = bucket;
+        this._storage = new PersistBase(bucket, `./dump/data/measure/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads a measure entry by key. Returns null if entry is missing or soft-deleted.
+     *
+     * @param key - Cache key within the bucket
+     * @returns Promise resolving to entry data, or null
+     */
+    async readMeasureData(key) {
+        if (await this._storage.hasValue(key)) {
+            const data = await this._storage.readValue(key);
+            return data.removed ? null : data;
+        }
+        return null;
+    }
+    /**
+     * Writes a measure entry under the given key.
+     *
+     * @param data - Data to cache
+     * @param key - Cache key within the bucket
+     * @returns Promise that resolves when write is complete
+     */
+    async writeMeasureData(data, key) {
+        await this._storage.writeValue(key, data);
+    }
+    /**
+     * Soft-deletes an entry by writing `removed: true` flag while preserving the file.
+     *
+     * @param key - Cache key within the bucket
+     * @returns Promise that resolves when removal is complete
+     */
+    async removeMeasureData(key) {
+        const data = await this._storage.readValue(key);
+        if (data) {
+            await this._storage.writeValue(key, Object.assign({}, data, { removed: true }));
+        }
+    }
+    /**
+     * Iterates all entries in the bucket, yielding keys of non-removed entries only.
+     *
+     * @returns AsyncGenerator yielding entry keys
+     */
+    async *listMeasureData() {
+        for await (const key of this._storage.keys()) {
+            const data = await this._storage.readValue(String(key));
+            if (data === null || data.removed) {
+                continue;
+            }
+            yield String(key);
+        }
+    }
+}
+/**
+ * No-op IPersistMeasureInstance implementation used by PersistMeasureUtils.useDummy().
+ * All reads return null, all writes/removes are discarded, list yields nothing.
+ */
+class PersistMeasureDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistMeasureInstanceCtor.
+     */
+    constructor(_bucket) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no cached entries).
+     * @returns Promise resolving to null
+     */
+    async readMeasureData(_key) { return null; }
+    /**
+     * No-op write (discards entry).
+     * @returns Promise that resolves immediately
+     */
+    async writeMeasureData(_data, _key) { }
+    /**
+     * No-op remove.
+     * @returns Promise that resolves immediately
+     */
+    async removeMeasureData(_key) { }
+    /**
+     * Empty generator — yields no entries.
+     * @returns AsyncGenerator that immediately completes
+     */
+    async *listMeasureData() { }
+}
 /**
  * Utility class for managing external API response cache persistence.
  *
@@ -2397,124 +3144,108 @@ const PersistLogAdapter = new PersistLogUtils();
  */
 class PersistMeasureUtils {
     constructor() {
-        this.PersistMeasureFactory = PersistBase;
-        this.getMeasureStorage = memoize(([bucket]) => bucket, (bucket) => Reflect.construct(this.PersistMeasureFactory, [
-            bucket,
-            `./dump/data/measure/`,
-        ]));
         /**
-         * Reads cached measure data for a given bucket and key.
+         * Constructor used to create per-bucket measure cache instances.
+         * Replaceable via usePersistMeasureAdapter() / useJson() / useDummy().
+         */
+        this.PersistMeasureInstanceCtor = PersistMeasureInstance;
+        /**
+         * Memoized factory creating one IPersistMeasureInstance per bucket.
+         */
+        this.getMeasureStorage = memoize(([bucket]) => bucket, (bucket) => Reflect.construct(this.PersistMeasureInstanceCtor, [bucket]));
+        /**
+         * Reads a measure entry from the given bucket by key.
+         * Lazily initializes the bucket instance on first access.
          *
-         * @param bucket - Storage bucket (e.g. aligned timestamp + symbol)
-         * @param key - Dynamic cache key within the bucket
-         * @returns Promise resolving to cached value or null if not found
+         * @param bucket - Storage bucket identifier
+         * @param key - Cache key within the bucket
+         * @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$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
             const isInitial = !this.getMeasureStorage.has(bucket);
-            const stateStorage = this.getMeasureStorage(bucket);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(key)) {
-                const data = await stateStorage.readValue(key);
-                return data.removed ? null : data;
-            }
-            return null;
+            const instance = this.getMeasureStorage(bucket);
+            await instance.waitForInit(isInitial);
+            return instance.readMeasureData(key);
         };
         /**
-         * Writes measure data to disk with atomic file writes.
+         * Writes a measure entry to the given bucket under the given key.
+         * Lazily initializes the bucket instance on first access.
          *
          * @param data - Data to cache
-         * @param bucket - Storage bucket (e.g. aligned timestamp + symbol)
-         * @param key - Dynamic cache key within the bucket
+         * @param bucket - Storage bucket identifier
+         * @param key - Cache key within the bucket
          * @returns Promise that resolves when write is complete
          */
         this.writeMeasureData = async (data, bucket, key) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_WRITE_DATA, {
-                bucket,
-                key,
-            });
+            LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
             const isInitial = !this.getMeasureStorage.has(bucket);
-            const stateStorage = this.getMeasureStorage(bucket);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(key, data);
+            const instance = this.getMeasureStorage(bucket);
+            await instance.waitForInit(isInitial);
+            return instance.writeMeasureData(data, key);
         };
         /**
-         * Marks a cached entry as removed (soft delete — file is kept on disk).
-         * After this call `readMeasureData` for the same key returns `null`.
+         * Soft-deletes a measure entry in the given bucket by setting `removed: true`.
+         * Lazily initializes the bucket instance on first access.
          *
-         * @param bucket - Storage bucket
-         * @param key - Dynamic cache key within the bucket
+         * @param bucket - Storage bucket identifier
+         * @param key - Cache key within the bucket
          * @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$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
             const isInitial = !this.getMeasureStorage.has(bucket);
-            const stateStorage = this.getMeasureStorage(bucket);
-            await stateStorage.waitForInit(isInitial);
-            const data = await stateStorage.readValue(key);
-            if (data) {
-                await stateStorage.writeValue(key, Object.assign({}, data, { removed: true }));
-            }
+            const instance = this.getMeasureStorage(bucket);
+            await instance.waitForInit(isInitial);
+            return instance.removeMeasureData(key);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistMeasureInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistMeasureInstance constructor
      */
     usePersistMeasureAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_PERSIST_MEASURE_ADAPTER);
-        this.PersistMeasureFactory = Ctor;
+        this.PersistMeasureInstanceCtor = Ctor;
+        this.getMeasureStorage.clear();
     }
     /**
-     * Async generator yielding all non-removed entity keys for a given bucket.
-     * Used by `CacheFileInstance.clear()` to iterate and soft-delete all entries.
+     * Iterates all non-removed measure entries for the given bucket.
+     * Lazily initializes the bucket instance on first access.
      *
-     * @param bucket - Storage bucket
-     * @returns AsyncGenerator yielding entity keys
+     * @param bucket - Storage bucket identifier
+     * @returns AsyncGenerator yielding entry keys
      */
     async *listMeasureData(bucket) {
         LOGGER_SERVICE$7.info(PERSIST_MEASURE_UTILS_METHOD_NAME_LIST_DATA, { bucket });
         const isInitial = !this.getMeasureStorage.has(bucket);
-        const stateStorage = this.getMeasureStorage(bucket);
-        await stateStorage.waitForInit(isInitial);
-        for await (const key of stateStorage.keys()) {
-            const data = await stateStorage.readValue(String(key));
-            if (data === null || data.removed) {
-                continue;
-            }
-            yield String(key);
-        }
+        const instance = this.getMeasureStorage(bucket);
+        await instance.waitForInit(isInitial);
+        yield* instance.listMeasureData();
     }
-    ;
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized bucket instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_MEASURE_UTILS_METHOD_NAME_CLEAR);
         this.getMeasureStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
+     * Switches to the default file-based PersistMeasureInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistMeasureAdapter(PersistBase);
+        this.usePersistMeasureAdapter(PersistMeasureInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
+     * Switches to PersistMeasureDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_MEASURE_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistMeasureAdapter(PersistDummy);
+        this.usePersistMeasureAdapter(PersistMeasureDummyInstance);
     }
 }
 /**
@@ -2522,6 +3253,129 @@ class PersistMeasureUtils {
  * Used by Cache.file for persistent caching of external API responses.
  */
 const PersistMeasureAdapter = new PersistMeasureUtils();
+/**
+ * Default file-based implementation of IPersistIntervalInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Soft delete via `removed: true` flag
+ * - listIntervalData filters out removed markers
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistIntervalInstance("my-interval-bucket");
+ * await instance.waitForInit(true);
+ * await instance.writeIntervalData({ id: "x", data: {}, removed: false }, "key1");
+ * const marker = await instance.readIntervalData("key1");
+ * await instance.removeIntervalData("key1");
+ * ```
+ */
+class PersistIntervalInstance {
+    /**
+     * Creates new interval marker persistence instance.
+     *
+     * @param bucket - Marker bucket identifier
+     */
+    constructor(bucket) {
+        this.bucket = bucket;
+        this._storage = new PersistBase(bucket, `./dump/data/interval/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads an interval marker by key. Returns null if marker is missing or soft-deleted.
+     *
+     * @param key - Marker key within the bucket
+     * @returns Promise resolving to stored data, or null
+     */
+    async readIntervalData(key) {
+        if (await this._storage.hasValue(key)) {
+            const data = await this._storage.readValue(key);
+            return data.removed ? null : data;
+        }
+        return null;
+    }
+    /**
+     * Writes an interval marker under the given key.
+     *
+     * @param data - Data to store
+     * @param key - Marker key within the bucket
+     * @returns Promise that resolves when write is complete
+     */
+    async writeIntervalData(data, key) {
+        await this._storage.writeValue(key, data);
+    }
+    /**
+     * Soft-deletes a marker by writing `removed: true` flag while preserving the file.
+     * Subsequent reads will return null, allowing the interval to fire again.
+     *
+     * @param key - Marker key within the bucket
+     * @returns Promise that resolves when removal is complete
+     */
+    async removeIntervalData(key) {
+        const data = await this._storage.readValue(key);
+        if (data) {
+            await this._storage.writeValue(key, Object.assign({}, data, { removed: true }));
+        }
+    }
+    /**
+     * Iterates all markers in the bucket, yielding keys of non-removed markers only.
+     *
+     * @returns AsyncGenerator yielding marker keys
+     */
+    async *listIntervalData() {
+        for await (const key of this._storage.keys()) {
+            const data = await this._storage.readValue(String(key));
+            if (data === null || data.removed) {
+                continue;
+            }
+            yield String(key);
+        }
+    }
+}
+/**
+ * No-op IPersistIntervalInstance implementation used by PersistIntervalUtils.useDummy().
+ * All reads return null, all writes/removes are discarded, list yields nothing.
+ */
+class PersistIntervalDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistIntervalInstanceCtor.
+     */
+    constructor(_bucket) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no interval markers).
+     * @returns Promise resolving to null
+     */
+    async readIntervalData(_key) { return null; }
+    /**
+     * No-op write (discards marker).
+     * @returns Promise that resolves immediately
+     */
+    async writeIntervalData(_data, _key) { }
+    /**
+     * No-op remove.
+     * @returns Promise that resolves immediately
+     */
+    async removeIntervalData(_key) { }
+    /**
+     * Empty generator — yields no markers.
+     * @returns AsyncGenerator that immediately completes
+     */
+    async *listIntervalData() { }
+}
 /**
  * Persistence layer for Interval.file once-per-interval signal firing.
  *
@@ -2531,124 +3385,108 @@ const PersistMeasureAdapter = new PersistMeasureUtils();
  */
 class PersistIntervalUtils {
     constructor() {
-        this.PersistIntervalFactory = PersistBase;
-        this.getIntervalStorage = memoize(([bucket]) => bucket, (bucket) => Reflect.construct(this.PersistIntervalFactory, [
-            bucket,
-            `./dump/data/interval/`,
-        ]));
         /**
-         * Reads interval data for a given bucket and key.
+         * Constructor used to create per-bucket interval marker instances.
+         * Replaceable via usePersistIntervalAdapter() / useJson() / useDummy().
+         */
+        this.PersistIntervalInstanceCtor = PersistIntervalInstance;
+        /**
+         * Memoized factory creating one IPersistIntervalInstance per bucket.
+         */
+        this.getIntervalStorage = memoize(([bucket]) => bucket, (bucket) => Reflect.construct(this.PersistIntervalInstanceCtor, [bucket]));
+        /**
+         * Reads an interval marker from the given bucket by key.
+         * Lazily initializes the bucket instance on first access.
          *
-         * @param bucket - Storage bucket (instance name + interval + index)
-         * @param key - Entity key within the bucket (symbol + aligned timestamp)
-         * @returns Promise resolving to stored value or null if not found
+         * @param bucket - Storage bucket identifier
+         * @param key - Marker key within the bucket
+         * @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$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_READ_DATA, { bucket, key });
             const isInitial = !this.getIntervalStorage.has(bucket);
-            const stateStorage = this.getIntervalStorage(bucket);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(key)) {
-                const data = await stateStorage.readValue(key);
-                return data.removed ? null : data;
-            }
-            return null;
+            const instance = this.getIntervalStorage(bucket);
+            await instance.waitForInit(isInitial);
+            return instance.readIntervalData(key);
         };
         /**
-         * Writes interval data to disk.
+         * Writes an interval marker to the given bucket under the given key.
+         * Lazily initializes the bucket instance on first access.
          *
          * @param data - Data to store
-         * @param bucket - Storage bucket
-         * @param key - Entity key within the bucket
+         * @param bucket - Storage bucket identifier
+         * @param key - Marker key within the bucket
          * @returns Promise that resolves when write is complete
          */
         this.writeIntervalData = async (data, bucket, key) => {
-            LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_WRITE_DATA, {
-                bucket,
-                key,
-            });
+            LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_WRITE_DATA, { bucket, key });
             const isInitial = !this.getIntervalStorage.has(bucket);
-            const stateStorage = this.getIntervalStorage(bucket);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(key, data);
+            const instance = this.getIntervalStorage(bucket);
+            await instance.waitForInit(isInitial);
+            return instance.writeIntervalData(data, key);
         };
         /**
-         * Marks an interval entry as removed (soft delete — file is kept on disk).
-         * After this call `readIntervalData` for the same key returns `null`,
-         * so the function will fire again on the next `IntervalFileInstance.run` call.
+         * Soft-deletes a marker in the given bucket by setting `removed: true`.
+         * Lazily initializes the bucket instance on first access.
          *
-         * @param bucket - Storage bucket
-         * @param key - Entity key within the bucket
+         * @param bucket - Storage bucket identifier
+         * @param key - Marker key within the bucket
          * @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$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_REMOVE_DATA, { bucket, key });
             const isInitial = !this.getIntervalStorage.has(bucket);
-            const stateStorage = this.getIntervalStorage(bucket);
-            await stateStorage.waitForInit(isInitial);
-            const data = await stateStorage.readValue(key);
-            if (data) {
-                await stateStorage.writeValue(key, Object.assign({}, data, { removed: true }));
-            }
+            const instance = this.getIntervalStorage(bucket);
+            await instance.waitForInit(isInitial);
+            return instance.removeIntervalData(key);
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistIntervalInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistIntervalInstance constructor
      */
     usePersistIntervalAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_PERSIST_INTERVAL_ADAPTER);
-        this.PersistIntervalFactory = Ctor;
+        this.PersistIntervalInstanceCtor = Ctor;
+        this.getIntervalStorage.clear();
     }
     /**
-     * Async generator yielding all non-removed entity keys for a given bucket.
-     * Used by `IntervalFileInstance.clear()` to iterate and soft-delete all entries.
+     * Iterates all non-removed markers for the given bucket.
+     * Lazily initializes the bucket instance on first access.
      *
-     * @param bucket - Storage bucket
-     * @returns AsyncGenerator yielding entity keys
+     * @param bucket - Storage bucket identifier
+     * @returns AsyncGenerator yielding marker keys
      */
     async *listIntervalData(bucket) {
         LOGGER_SERVICE$7.info(PERSIST_INTERVAL_UTILS_METHOD_NAME_LIST_DATA, { bucket });
         const isInitial = !this.getIntervalStorage.has(bucket);
-        const stateStorage = this.getIntervalStorage(bucket);
-        await stateStorage.waitForInit(isInitial);
-        for await (const key of stateStorage.keys()) {
-            const data = await stateStorage.readValue(String(key));
-            if (data === null || data.removed) {
-                continue;
-            }
-            yield String(key);
-        }
+        const instance = this.getIntervalStorage(bucket);
+        await instance.waitForInit(isInitial);
+        yield* instance.listIntervalData();
     }
-    ;
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations.
+     * Clears the memoized bucket instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_CLEAR);
         this.getIntervalStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
+     * Switches to the default file-based PersistIntervalInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistIntervalAdapter(PersistBase);
+        this.usePersistIntervalAdapter(PersistIntervalInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
+     * Switches to PersistIntervalDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_INTERVAL_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistIntervalAdapter(PersistDummy);
+        this.usePersistIntervalAdapter(PersistIntervalDummyInstance);
     }
 }
 /**
@@ -2656,6 +3494,154 @@ class PersistIntervalUtils {
  * Used by Interval.file for persistent once-per-interval signal firing.
  */
 const PersistIntervalAdapter = new PersistIntervalUtils();
+/**
+ * Default file-based implementation of IPersistMemoryInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Soft delete via `removed: true` flag
+ * - listMemoryData filters out removed entries
+ * - dispose is a no-op (memo cache is managed by PersistMemoryUtils)
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistMemoryInstance("signal-1", "context-bucket");
+ * await instance.waitForInit(true);
+ * await instance.writeMemoryData(entryData, "memory-id-1");
+ * const data = await instance.readMemoryData("memory-id-1");
+ * ```
+ */
+class PersistMemoryInstance {
+    /**
+     * Creates new memory persistence instance.
+     *
+     * @param signalId - Signal identifier (entity folder name)
+     * @param bucketName - Bucket name (subfolder under memory/)
+     */
+    constructor(signalId, bucketName) {
+        this.signalId = signalId;
+        this.bucketName = bucketName;
+        this._storage = new PersistBase(bucketName, `./dump/memory/${signalId}/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads a memory entry by id. Returns null if entry is missing or soft-deleted.
+     *
+     * @param memoryId - Memory entry identifier
+     * @returns Promise resolving to entry data, or null
+     */
+    async readMemoryData(memoryId) {
+        if (await this._storage.hasValue(memoryId)) {
+            const data = await this._storage.readValue(memoryId);
+            return data.removed ? null : data;
+        }
+        return null;
+    }
+    /**
+     * Checks whether a memory entry exists on disk (regardless of removed flag).
+     *
+     * @param memoryId - Memory entry identifier
+     * @returns Promise resolving to true if entry file exists
+     */
+    async hasMemoryData(memoryId) {
+        return await this._storage.hasValue(memoryId);
+    }
+    /**
+     * Writes a memory entry under the given id.
+     *
+     * @param data - Entry data to persist
+     * @param memoryId - Memory entry identifier
+     * @returns Promise that resolves when write is complete
+     */
+    async writeMemoryData(data, memoryId) {
+        await this._storage.writeValue(memoryId, data);
+    }
+    /**
+     * Soft-deletes a memory entry by writing `removed: true` flag.
+     *
+     * @param memoryId - Memory entry identifier
+     * @returns Promise that resolves when removal is complete
+     */
+    async removeMemoryData(memoryId) {
+        const data = await this._storage.readValue(memoryId);
+        if (data) {
+            await this._storage.writeValue(memoryId, Object.assign({}, data, { removed: true }));
+        }
+    }
+    /**
+     * Iterates all memory entries in the bucket, yielding id + data tuples
+     * for non-removed entries only.
+     *
+     * @returns AsyncGenerator yielding `{ memoryId, data }` tuples
+     */
+    async *listMemoryData() {
+        for await (const memoryId of this._storage.keys()) {
+            const data = await this._storage.readValue(String(memoryId));
+            if (data === null || data.removed) {
+                continue;
+            }
+            yield { memoryId: String(memoryId), data };
+        }
+    }
+    /**
+     * No-op for the default file-based implementation.
+     * Resource cleanup (memo cache invalidation) is handled by PersistMemoryUtils.dispose().
+     */
+    dispose() { }
+}
+/**
+ * No-op IPersistMemoryInstance implementation used by PersistMemoryUtils.useDummy().
+ * All reads return null/false, all writes/removes are discarded, list yields nothing.
+ */
+class PersistMemoryDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistMemoryInstanceCtor.
+     */
+    constructor(_signalId, _bucketName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no memory entries).
+     * @returns Promise resolving to null
+     */
+    async readMemoryData(_memoryId) { return null; }
+    /**
+     * Always returns false (no memory entries exist).
+     * @returns Promise resolving to false
+     */
+    async hasMemoryData(_memoryId) { return false; }
+    /**
+     * No-op write (discards entry).
+     * @returns Promise that resolves immediately
+     */
+    async writeMemoryData(_data, _memoryId) { }
+    /**
+     * No-op remove.
+     * @returns Promise that resolves immediately
+     */
+    async removeMemoryData(_memoryId) { }
+    /**
+     * Empty generator — yields no entries.
+     * @returns AsyncGenerator that immediately completes
+     */
+    async *listMemoryData() { }
+    /**
+     * No-op dispose.
+     */
+    dispose() { }
+}
 /**
  * Utility class for managing memory entry persistence.
  *
@@ -2671,51 +3657,50 @@ const PersistIntervalAdapter = new PersistIntervalUtils();
  */
 class PersistMemoryUtils {
     constructor() {
-        this.PersistMemoryFactory = PersistBase;
-        this.getMemoryStorage = memoize(([signalId, bucketName]) => `${signalId}:${bucketName}`, (signalId, bucketName) => Reflect.construct(this.PersistMemoryFactory, [
-            bucketName,
-            `./dump/memory/${signalId}/`,
-        ]));
         /**
-         * Initializes the storage for a given (signalId, bucketName) pair.
+         * Constructor used to create per-context memory instances.
+         * Replaceable via usePersistMemoryAdapter() / useJson() / useDummy().
+         */
+        this.PersistMemoryInstanceCtor = PersistMemoryInstance;
+        /**
+         * Memoized factory creating one IPersistMemoryInstance per (signalId, bucketName) pair.
+         */
+        this.getMemoryStorage = memoize(([signalId, bucketName]) => `${signalId}:${bucketName}`, (signalId, bucketName) => Reflect.construct(this.PersistMemoryInstanceCtor, [signalId, bucketName]));
+        /**
+         * Initializes the memory storage for the given context.
+         * Skips initialization when `initial` is false (used to gate first-time setup).
          *
-         * @param signalId - Signal identifier (entity folder name)
-         * @param bucketName - Bucket name (subfolder under memory/)
+         * @param signalId - Signal identifier
+         * @param bucketName - Bucket name
          * @param initial - Whether this is the first initialization
          * @returns Promise that resolves when initialization is complete
          */
         this.waitForInit = async (signalId, bucketName, initial) => {
             const key = `${signalId}:${bucketName}`;
             const isInitial = initial && !this.getMemoryStorage.has(key);
-            const stateStorage = this.getMemoryStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
+            const instance = this.getMemoryStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
         };
         /**
-         * Reads a memory entry from persistence storage.
+         * Reads a memory entry for the given context and id.
+         * Lazily initializes the instance on first access.
          *
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
          * @param memoryId - Memory entry identifier
-         * @returns Promise resolving to entry data or null if not found
+         * @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$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
-            const stateStorage = this.getMemoryStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(memoryId)) {
-                const data = await stateStorage.readValue(memoryId);
-                return data.removed ? null : data;
-            }
-            return null;
+            const instance = this.getMemoryStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
+            return instance.readMemoryData(memoryId);
         };
         /**
-         * Checks if a memory entry exists in persistence storage.
+         * Checks whether a memory entry exists on disk for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
@@ -2723,19 +3708,16 @@ 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$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_HAS_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
-            const stateStorage = this.getMemoryStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
-            return await stateStorage.hasValue(memoryId);
+            const instance = this.getMemoryStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
+            return instance.hasMemoryData(memoryId);
         };
         /**
-         * Writes a memory entry to disk with atomic file writes.
+         * Writes a memory entry for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param data - Entry data to persist
          * @param signalId - Signal identifier
@@ -2744,19 +3726,16 @@ class PersistMemoryUtils {
          * @returns Promise that resolves when write is complete
          */
         this.writeMemoryData = async (data, signalId, bucketName, memoryId) => {
-            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_WRITE_DATA, {
-                signalId,
-                bucketName,
-                memoryId,
-            });
+            LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
-            const stateStorage = this.getMemoryStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(memoryId, data);
+            const instance = this.getMemoryStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
+            return instance.writeMemoryData(data, memoryId);
         };
         /**
-         * Marks a memory entry as removed (soft delete — file is kept on disk).
+         * Soft-deletes a memory entry for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
@@ -2764,36 +3743,27 @@ 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$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_REMOVE_DATA, { signalId, bucketName, memoryId });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getMemoryStorage.has(key);
-            const stateStorage = this.getMemoryStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
-            const data = await stateStorage.readValue(memoryId);
-            if (data) {
-                await stateStorage.writeValue(memoryId, Object.assign({}, data, { removed: true }));
-            }
+            const instance = this.getMemoryStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
+            return instance.removeMemoryData(memoryId);
         };
         /**
-         * Clears the memoized storage cache.
-         * Call this when process.cwd() changes between strategy iterations
-         * so new storage instances are created with the updated base path.
+         * Clears the memoized instance cache.
+         * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
             LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_CLEAR);
             this.getMemoryStorage.clear();
         };
         /**
-         * Disposes of the memory adapter and releases any resources.
-         * Call this when a signal is removed to clean up its associated storage.
+         * Drops the memoized instance for the given context.
+         * Call when a signal is removed to clean up its associated storage entry.
          *
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
-         * @returns void
          */
         this.dispose = (signalId, bucketName) => {
             LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_DISPOSE);
@@ -2802,64 +3772,46 @@ class PersistMemoryUtils {
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistMemoryInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
-     *
-     * @example
-     * ```typescript
-     * class RedisPersist extends PersistBase {
-     *   async readValue(id) { return JSON.parse(await redis.get(id)); }
-     *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
-     * }
-     * PersistMemoryAdapter.usePersistMemoryAdapter(RedisPersist);
-     * ```
+     * @param Ctor - Custom IPersistMemoryInstance constructor
      */
     usePersistMemoryAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_USE_PERSIST_MEMORY_ADAPTER);
-        this.PersistMemoryFactory = Ctor;
+        this.PersistMemoryInstanceCtor = Ctor;
+        this.getMemoryStorage.clear();
     }
     /**
-     * Lists all memory entry IDs for a given (signalId, bucketName) pair.
+     * Iterates all non-removed memory entries for the given context.
      * Used by MemoryPersistInstance to rebuild the BM25 index on init.
+     * Lazily initializes the instance on first access.
      *
      * @param signalId - Signal identifier
      * @param bucketName - Bucket name
-     * @returns AsyncGenerator yielding memory entry IDs
+     * @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$7.info(PERSIST_MEMORY_UTILS_METHOD_NAME_LIST_DATA, { signalId, bucketName });
         const key = `${signalId}:${bucketName}`;
         const isInitial = !this.getMemoryStorage.has(key);
-        const stateStorage = this.getMemoryStorage(signalId, bucketName);
-        await stateStorage.waitForInit(isInitial);
-        for await (const memoryId of stateStorage.keys()) {
-            const data = await stateStorage.readValue(String(memoryId));
-            if (data === null || data.removed) {
-                continue;
-            }
-            yield { memoryId: String(memoryId), data };
-        }
+        const instance = this.getMemoryStorage(signalId, bucketName);
+        await instance.waitForInit(isInitial);
+        yield* instance.listMemoryData();
     }
-    ;
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistMemoryInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistMemoryAdapter(PersistBase);
+        this.usePersistMemoryAdapter(PersistMemoryInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistMemoryDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistMemoryAdapter(PersistDummy);
+        this.usePersistMemoryAdapter(PersistMemoryDummyInstance);
     }
 }
 /**
@@ -2879,6 +3831,100 @@ class PersistMemoryUtils {
  * ```
  */
 const PersistMemoryAdapter = new PersistMemoryUtils();
+/**
+ * Default file-based implementation of IPersistRecentInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses symbol as entity ID within a per-context PersistBase
+ * - Context key includes backtest/live mode and optional frameName
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistRecentInstance("BTCUSDT", "my-strategy", "binance", "frame-1", false);
+ * await instance.waitForInit(true);
+ * await instance.writeRecentData(publicSignalRow);
+ * const recent = await instance.readRecentData();
+ * ```
+ */
+class PersistRecentInstance {
+    /**
+     * Creates new recent signal persistence instance.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     * @param frameName - Frame identifier (may be empty for live mode)
+     * @param backtest - True for backtest mode, false for live mode
+     */
+    constructor(symbol, strategyName, exchangeName, frameName, backtest) {
+        this.symbol = symbol;
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
+        this.backtest = backtest;
+        const parts = [symbol, strategyName, exchangeName];
+        if (frameName)
+            parts.push(frameName);
+        parts.push(backtest ? "backtest" : "live");
+        this._storage = new PersistBase(parts.join("_"), `./dump/data/recent/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the persisted recent signal using `symbol` as the entity key.
+     *
+     * @returns Promise resolving to recent signal or null if not found
+     */
+    async readRecentData() {
+        if (await this._storage.hasValue(this.symbol)) {
+            return await this._storage.readValue(this.symbol);
+        }
+        return null;
+    }
+    /**
+     * Writes the recent signal using `symbol` as the entity key.
+     *
+     * @param signalRow - Recent signal data to persist
+     * @returns Promise that resolves when write is complete
+     */
+    async writeRecentData(signalRow) {
+        await this._storage.writeValue(this.symbol, signalRow);
+    }
+}
+/**
+ * No-op IPersistRecentInstance implementation used by PersistRecentUtils.useDummy().
+ * All reads return null, all writes are discarded.
+ */
+class PersistRecentDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistRecentInstanceCtor.
+     */
+    constructor(_symbol, _strategyName, _exchangeName, _frameName, _backtest) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no recent signal).
+     * @returns Promise resolving to null
+     */
+    async readRecentData() { return null; }
+    /**
+     * No-op write (discards recent signal).
+     * @returns Promise that resolves immediately
+     */
+    async writeRecentData(_signalRow) { }
+}
 /**
  * Utility class for managing recent signal persistence.
  *
@@ -2892,95 +3938,105 @@ const PersistMemoryAdapter = new PersistMemoryUtils();
  */
 class PersistRecentUtils {
     constructor() {
-        this.PersistRecentFactory = PersistBase;
-        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => this.createKeyParts(symbol, strategyName, exchangeName, frameName, backtest).join(":"), (symbol, strategyName, exchangeName, frameName, backtest) => Reflect.construct(this.PersistRecentFactory, [
-            this.createKeyParts(symbol, strategyName, exchangeName, frameName, backtest).join("_"),
-            `./dump/data/recent/`,
-        ]));
         /**
-         * Reads the latest persisted recent signal for a given context.
-         *
-         * Returns null if no recent signal exists.
+         * Constructor used to create per-context recent signal instances.
+         * Replaceable via usePersistRecentAdapter() / useJson() / useDummy().
+         */
+        this.PersistRecentInstanceCtor = PersistRecentInstance;
+        /**
+         * Memoized factory creating one IPersistRecentInstance per context tuple.
+         */
+        this.getStorage = memoize(([symbol, strategyName, exchangeName, frameName, backtest]) => this.createKey(symbol, strategyName, exchangeName, frameName, backtest), (symbol, strategyName, exchangeName, frameName, backtest) => Reflect.construct(this.PersistRecentInstanceCtor, [symbol, strategyName, exchangeName, frameName, backtest]));
+        /**
+         * Reads the latest recent signal for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
-         * @param frameName - Frame identifier
-         * @returns Promise resolving to recent signal or null
+         * @param frameName - Frame identifier (may be empty)
+         * @param backtest - True for backtest mode, false for live mode
+         * @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);
-            const key = this.createKeyParts(symbol, strategyName, exchangeName, frameName, backtest).join(":");
+            const key = this.createKey(symbol, strategyName, exchangeName, frameName, backtest);
             const isInitial = !this.getStorage.has(key);
-            const stateStorage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(symbol)) {
-                return await stateStorage.readValue(symbol);
-            }
-            return null;
+            const instance = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
+            await instance.waitForInit(isInitial);
+            return instance.readRecentData();
         };
         /**
-         * Writes the latest recent signal to disk with atomic file writes.
-         *
-         * Uses symbol as the entity ID within the per-context storage instance.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Writes the latest recent signal for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param signalRow - Recent signal data to persist
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
-         * @param frameName - Frame identifier
+         * @param frameName - Frame identifier (may be empty)
+         * @param backtest - True for backtest mode, false for live mode
          * @returns Promise that resolves when write is complete
          */
         this.writeRecentData = async (signalRow, symbol, strategyName, exchangeName, frameName, backtest) => {
             LOGGER_SERVICE$7.info(PERSIST_RECENT_UTILS_METHOD_NAME_WRITE_DATA);
-            const key = this.createKeyParts(symbol, strategyName, exchangeName, frameName, backtest).join(":");
+            const key = this.createKey(symbol, strategyName, exchangeName, frameName, backtest);
             const isInitial = !this.getStorage.has(key);
-            const stateStorage = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(symbol, signalRow);
+            const instance = this.getStorage(symbol, strategyName, exchangeName, frameName, backtest);
+            await instance.waitForInit(isInitial);
+            return instance.writeRecentData(signalRow);
         };
     }
-    createKeyParts(symbol, strategyName, exchangeName, frameName, backtest) {
+    /**
+     * Builds the composite memoization key for a recent signal context.
+     * Includes optional frameName and the backtest/live mode flag.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     * @param frameName - Frame identifier (omitted from key if empty)
+     * @param backtest - True for backtest mode, false for live mode
+     * @returns Composite key string
+     */
+    createKey(symbol, strategyName, exchangeName, frameName, backtest) {
         const parts = [symbol, strategyName, exchangeName];
         if (frameName)
             parts.push(frameName);
         parts.push(backtest ? "backtest" : "live");
-        return parts;
+        return parts.join(":");
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistRecentInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistRecentInstance constructor
      */
     usePersistRecentAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_RECENT_UTILS_METHOD_NAME_USE_PERSIST_RECENT_ADAPTER);
-        this.PersistRecentFactory = Ctor;
+        this.PersistRecentInstanceCtor = Ctor;
+        this.getStorage.clear();
     }
     /**
-     * Clears the memoized storage cache.
-     * Call this when process.cwd() changes between strategy iterations
-     * so new storage instances are created with the updated base path.
+     * Clears the memoized instance cache.
+     * Call when process.cwd() changes between strategy iterations.
      */
     clear() {
         LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_CLEAR);
         this.getStorage.clear();
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Switches to the default file-based PersistRecentInstance.
      */
     useJson() {
         LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistRecentAdapter(PersistBase);
+        this.usePersistRecentAdapter(PersistRecentInstance);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Switches to PersistRecentDummyInstance (all operations are no-ops).
      */
     useDummy() {
         LOGGER_SERVICE$7.log(PERSIST_RECENT_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistRecentAdapter(PersistDummy);
+        this.usePersistRecentAdapter(PersistRecentDummyInstance);
     }
 }
 /**
@@ -2988,6 +4044,99 @@ class PersistRecentUtils {
  * Used by RecentPersistBacktestUtils/RecentPersistLiveUtils for recent signal persistence.
  */
 const PersistRecentAdapter = new PersistRecentUtils();
+/**
+ * Default file-based implementation of IPersistStateInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses bucketName as entity ID within a per-signal PersistBase
+ * - dispose is a no-op (memo cache is managed by PersistStateUtils)
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistStateInstance("signal-1", "counter");
+ * await instance.waitForInit(true);
+ * await instance.writeStateData({ id: "counter", data: { count: 1 } });
+ * const state = await instance.readStateData();
+ * ```
+ */
+class PersistStateInstance {
+    /**
+     * Creates new state persistence instance.
+     *
+     * @param signalId - Signal identifier (folder name under state/)
+     * @param bucketName - Bucket name (file name)
+     */
+    constructor(signalId, bucketName) {
+        this.signalId = signalId;
+        this.bucketName = bucketName;
+        this._storage = new PersistBase(bucketName, `./dump/state/${signalId}/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the persisted state using `bucketName` as the entity key.
+     *
+     * @returns Promise resolving to state data or null if not found
+     */
+    async readStateData() {
+        if (await this._storage.hasValue(this.bucketName)) {
+            return await this._storage.readValue(this.bucketName);
+        }
+        return null;
+    }
+    /**
+     * Writes the state using `bucketName` as the entity key.
+     *
+     * @param data - State data to persist
+     * @returns Promise that resolves when write is complete
+     */
+    async writeStateData(data) {
+        await this._storage.writeValue(this.bucketName, data);
+    }
+    /**
+     * No-op for the default file-based implementation.
+     * Resource cleanup (memo cache invalidation) is handled by PersistStateUtils.dispose().
+     */
+    dispose() { }
+}
+/**
+ * No-op IPersistStateInstance implementation used by PersistStateUtils.useDummy().
+ * All reads return null, all writes are discarded.
+ */
+class PersistStateDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistStateInstanceCtor.
+     */
+    constructor(_signalId, _bucketName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no persisted state).
+     * @returns Promise resolving to null
+     */
+    async readStateData() { return null; }
+    /**
+     * No-op write (discards state).
+     * @returns Promise that resolves immediately
+     */
+    async writeStateData(_data) { }
+    /**
+     * No-op dispose.
+     */
+    dispose() { }
+}
 /**
  * Utility class for managing state persistence.
  *
@@ -3002,96 +4151,89 @@ const PersistRecentAdapter = new PersistRecentUtils();
  */
 class PersistStateUtils {
     constructor() {
-        this.PersistStateFactory = PersistBase;
-        this.getStateStorage = memoize(([signalId, bucketName]) => `${signalId}:${bucketName}`, (signalId, bucketName) => Reflect.construct(this.PersistStateFactory, [
-            bucketName,
-            `./dump/state/${signalId}/`,
-        ]));
         /**
-         * Initializes the storage for a given (signalId, bucketName) pair.
+         * Constructor used to create per-context state instances.
+         * Replaceable via usePersistStateAdapter() / useJson() / useDummy().
+         */
+        this.PersistStateInstanceCtor = PersistStateInstance;
+        /**
+         * Memoized factory creating one IPersistStateInstance per (signalId, bucketName) pair.
+         */
+        this.getStateStorage = memoize(([signalId, bucketName]) => `${signalId}:${bucketName}`, (signalId, bucketName) => Reflect.construct(this.PersistStateInstanceCtor, [signalId, bucketName]));
+        /**
+         * Initializes the state storage for the given context.
+         * Skips initialization when `initial` is false (used to gate first-time setup).
          *
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
          * @param initial - Whether this is the first initialization
+         * @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$7.info(PERSIST_STATE_UTILS_METHOD_NAME_WAIT_FOR_INIT, { signalId, bucketName, initial });
             const key = `${signalId}:${bucketName}`;
             const isInitial = initial && !this.getStateStorage.has(key);
-            const stateStorage = this.getStateStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
+            const instance = this.getStateStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
         };
         /**
-         * Reads a state entry from persistence storage.
+         * Reads persisted state for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
-         * @returns Promise resolving to entry data or null if not found
+         * @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$7.info(PERSIST_STATE_UTILS_METHOD_NAME_READ_DATA, { signalId, bucketName });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getStateStorage.has(key);
-            const stateStorage = this.getStateStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(bucketName)) {
-                return await stateStorage.readValue(bucketName);
-            }
-            return null;
+            const instance = this.getStateStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
+            return instance.readStateData();
         };
         /**
-         * Writes a state entry to disk with atomic file writes.
+         * Writes state for the given context.
+         * Lazily initializes the instance on first access.
          *
-         * @param data - Entry data to persist
+         * @param data - State data to persist
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
+         * @returns Promise that resolves when write is complete
          */
         this.writeStateData = async (data, signalId, bucketName) => {
-            LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_WRITE_DATA, {
-                signalId,
-                bucketName,
-            });
+            LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_WRITE_DATA, { signalId, bucketName });
             const key = `${signalId}:${bucketName}`;
             const isInitial = !this.getStateStorage.has(key);
-            const stateStorage = this.getStateStorage(signalId, bucketName);
-            await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(bucketName, data);
+            const instance = this.getStateStorage(signalId, bucketName);
+            await instance.waitForInit(isInitial);
+            return instance.writeStateData(data);
         };
         /**
-         * Switches to a dummy persist adapter that discards all writes.
-         * All future persistence writes will be no-ops.
+         * Switches to PersistStateDummyInstance (all operations are no-ops).
          */
         this.useDummy = () => {
             LOGGER_SERVICE$7.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_DUMMY);
-            this.usePersistStateAdapter(PersistDummy);
+            this.usePersistStateAdapter(PersistStateDummyInstance);
         };
         /**
-         * Switches to the default JSON persist adapter.
-         * All future persistence writes will use JSON storage.
+         * Switches to the default file-based PersistStateInstance.
          */
         this.useJson = () => {
             LOGGER_SERVICE$7.log(PERSIST_STATE_UTILS_METHOD_NAME_USE_JSON);
-            this.usePersistStateAdapter(PersistBase);
+            this.usePersistStateAdapter(PersistStateInstance);
         };
         /**
-         * Clears the memoized storage cache.
-         * Call this when process.cwd() changes between strategy iterations
-         * so new storage instances are created with the updated base path.
+         * Clears the memoized instance cache.
+         * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
             LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_CLEAR);
             this.getStateStorage.clear();
         };
         /**
-         * Disposes of the state adapter and releases any resources.
-         * Call this when a signal is removed to clean up its associated storage.
+         * Drops the memoized instance for the given context.
+         * Call when a signal is removed to clean up its associated storage entry.
          *
          * @param signalId - Signal identifier
          * @param bucketName - Bucket name
@@ -3103,13 +4245,15 @@ class PersistStateUtils {
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistStateInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistStateInstance constructor
      */
     usePersistStateAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_STATE_UTILS_METHOD_NAME_USE_PERSIST_STATE_ADAPTER);
-        this.PersistStateFactory = Ctor;
+        this.PersistStateInstanceCtor = Ctor;
+        this.getStateStorage.clear();
     }
 }
 /**
@@ -3117,6 +4261,101 @@ class PersistStateUtils {
  * Used by StatePersistInstance for crash-safe state persistence.
  */
 const PersistStateAdapter = new PersistStateUtils();
+/**
+ * Default file-based implementation of IPersistSessionInstance.
+ *
+ * Features:
+ * - Wraps PersistBase for atomic JSON writes
+ * - Uses frameName as entity ID within a per-strategy/exchange PersistBase
+ * - dispose is a no-op (memo cache is managed by PersistSessionUtils)
+ *
+ * @example
+ * ```typescript
+ * const instance = new PersistSessionInstance("my-strategy", "binance", "frame-1");
+ * await instance.waitForInit(true);
+ * await instance.writeSessionData({ id: "frame-1", data: { session: "state" } });
+ * const session = await instance.readSessionData();
+ * ```
+ */
+class PersistSessionInstance {
+    /**
+     * Creates new session persistence instance.
+     *
+     * @param strategyName - Strategy identifier
+     * @param exchangeName - Exchange identifier
+     * @param frameName - Frame identifier (also used as entity ID)
+     */
+    constructor(strategyName, exchangeName, frameName) {
+        this.strategyName = strategyName;
+        this.exchangeName = exchangeName;
+        this.frameName = frameName;
+        this._storage = new PersistBase(frameName, `./dump/session/${strategyName}/${exchangeName}/`);
+    }
+    /**
+     * Initializes the underlying PersistBase storage.
+     *
+     * @param initial - Whether this is the first initialization
+     * @returns Promise that resolves when initialization is complete
+     */
+    async waitForInit(initial) {
+        await this._storage.waitForInit(initial);
+    }
+    /**
+     * Reads the persisted session data using `frameName` as the entity key.
+     *
+     * @returns Promise resolving to session data or null if not found
+     */
+    async readSessionData() {
+        if (await this._storage.hasValue(this.frameName)) {
+            return await this._storage.readValue(this.frameName);
+        }
+        return null;
+    }
+    /**
+     * Writes the session data using `frameName` as the entity key.
+     *
+     * @param data - Session data to persist
+     * @returns Promise that resolves when write is complete
+     */
+    async writeSessionData(data) {
+        await this._storage.writeValue(this.frameName, data);
+    }
+    /**
+     * No-op for the default file-based implementation.
+     * Resource cleanup (memo cache invalidation) is handled by PersistSessionUtils.dispose().
+     */
+    dispose() { }
+}
+/**
+ * No-op IPersistSessionInstance implementation used by PersistSessionUtils.useDummy().
+ * All reads return null, all writes are discarded.
+ */
+class PersistSessionDummyInstance {
+    /**
+     * No-op constructor.
+     * Context arguments are accepted to satisfy TPersistSessionInstanceCtor.
+     */
+    constructor(_strategyName, _exchangeName, _frameName) { }
+    /**
+     * No-op initialization.
+     * @returns Promise that resolves immediately
+     */
+    async waitForInit(_initial) { }
+    /**
+     * Always returns null (no persisted session).
+     * @returns Promise resolving to null
+     */
+    async readSessionData() { return null; }
+    /**
+     * No-op write (discards session data).
+     * @returns Promise that resolves immediately
+     */
+    async writeSessionData(_data) { }
+    /**
+     * No-op dispose.
+     */
+    dispose() { }
+}
 /**
  * Utility class for managing session persistence.
  *
@@ -3131,102 +4370,93 @@ const PersistStateAdapter = new PersistStateUtils();
  */
 class PersistSessionUtils {
     constructor() {
-        this.PersistSessionFactory = PersistBase;
-        this.getSessionStorage = memoize(([strategyName, exchangeName, frameName]) => `${strategyName}:${exchangeName}:${frameName}`, (strategyName, exchangeName, frameName) => Reflect.construct(this.PersistSessionFactory, [
-            frameName,
-            `./dump/session/${strategyName}/${exchangeName}/`,
-        ]));
         /**
-         * Initializes the storage for a given (strategyName, exchangeName, frameName) triple.
+         * Constructor used to create per-context session instances.
+         * Replaceable via usePersistSessionAdapter() / useJson() / useDummy().
+         */
+        this.PersistSessionInstanceCtor = PersistSessionInstance;
+        /**
+         * Memoized factory creating one IPersistSessionInstance per
+         * (strategyName, exchangeName, frameName) triple.
+         */
+        this.getSessionStorage = memoize(([strategyName, exchangeName, frameName]) => `${strategyName}:${exchangeName}:${frameName}`, (strategyName, exchangeName, frameName) => Reflect.construct(this.PersistSessionInstanceCtor, [strategyName, exchangeName, frameName]));
+        /**
+         * Initializes the session storage for the given context.
+         * Skips initialization when `initial` is false (used to gate first-time setup).
          *
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
          * @param frameName - Frame identifier
          * @param initial - Whether this is the first initialization
+         * @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$7.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 sessionStorage = this.getSessionStorage(strategyName, exchangeName, frameName);
-            await sessionStorage.waitForInit(isInitial);
+            const instance = this.getSessionStorage(strategyName, exchangeName, frameName);
+            await instance.waitForInit(isInitial);
         };
         /**
-         * Reads a session entry from persistence storage.
+         * Reads persisted session data for the given context.
+         * Lazily initializes the instance on first access.
          *
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
          * @param frameName - Frame identifier
-         * @returns Promise resolving to entry data or null if not found
+         * @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$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_READ_DATA, { strategyName, exchangeName, frameName });
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             const isInitial = !this.getSessionStorage.has(key);
-            const sessionStorage = this.getSessionStorage(strategyName, exchangeName, frameName);
-            await sessionStorage.waitForInit(isInitial);
-            if (await sessionStorage.hasValue(frameName)) {
-                return await sessionStorage.readValue(frameName);
-            }
-            return null;
+            const instance = this.getSessionStorage(strategyName, exchangeName, frameName);
+            await instance.waitForInit(isInitial);
+            return instance.readSessionData();
         };
         /**
-         * Writes a session entry to disk with atomic file writes.
+         * Writes session data for the given context.
+         * Lazily initializes the instance on first access.
          *
-         * @param data - Entry data to persist
+         * @param data - Session data to persist
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
          * @param frameName - Frame identifier
+         * @returns Promise that resolves when write is complete
          */
         this.writeSessionData = async (data, strategyName, exchangeName, frameName) => {
-            LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_WRITE_DATA, {
-                strategyName,
-                exchangeName,
-                frameName,
-            });
+            LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_WRITE_DATA, { strategyName, exchangeName, frameName });
             const key = `${strategyName}:${exchangeName}:${frameName}`;
             const isInitial = !this.getSessionStorage.has(key);
-            const sessionStorage = this.getSessionStorage(strategyName, exchangeName, frameName);
-            await sessionStorage.waitForInit(isInitial);
-            await sessionStorage.writeValue(frameName, data);
+            const instance = this.getSessionStorage(strategyName, exchangeName, frameName);
+            await instance.waitForInit(isInitial);
+            return instance.writeSessionData(data);
         };
         /**
-         * Switches to a dummy persist adapter that discards all writes.
-         * All future persistence writes will be no-ops.
+         * Switches to PersistSessionDummyInstance (all operations are no-ops).
          */
         this.useDummy = () => {
             LOGGER_SERVICE$7.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_DUMMY);
-            this.usePersistSessionAdapter(PersistDummy);
+            this.usePersistSessionAdapter(PersistSessionDummyInstance);
         };
         /**
-         * Switches to the default JSON persist adapter.
-         * All future persistence writes will use JSON storage.
+         * Switches to the default file-based PersistSessionInstance.
          */
         this.useJson = () => {
             LOGGER_SERVICE$7.log(PERSIST_SESSION_UTILS_METHOD_NAME_USE_JSON);
-            this.usePersistSessionAdapter(PersistBase);
+            this.usePersistSessionAdapter(PersistSessionInstance);
         };
         /**
-         * Clears the memoized storage cache.
-         * Call this when process.cwd() changes between strategy iterations
-         * so new storage instances are created with the updated base path.
+         * Clears the memoized instance cache.
+         * Call when process.cwd() changes between strategy iterations.
          */
         this.clear = () => {
             LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_CLEAR);
             this.getSessionStorage.clear();
         };
         /**
-         * Disposes of the session adapter and releases any resources.
-         * Call this when a session is removed to clean up its associated storage.
+         * Drops the memoized instance for the given context.
+         * Call when a session is removed to clean up its associated storage entry.
          *
          * @param strategyName - Strategy identifier
          * @param exchangeName - Exchange identifier
@@ -3239,13 +4469,15 @@ class PersistSessionUtils {
         };
     }
     /**
-     * Registers a custom persistence adapter.
+     * Registers a custom IPersistSessionInstance constructor.
+     * Clears the memoization cache so subsequent calls use the new adapter.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param Ctor - Custom IPersistSessionInstance constructor
      */
     usePersistSessionAdapter(Ctor) {
         LOGGER_SERVICE$7.info(PERSIST_SESSION_UTILS_METHOD_NAME_USE_PERSIST_SESSION_ADAPTER);
-        this.PersistSessionFactory = Ctor;
+        this.PersistSessionInstanceCtor = Ctor;
+        this.getSessionStorage.clear();
     }
 }
 /**
@@ -6677,7 +7909,7 @@ const CALL_PARTIAL_CLEAR_FN = trycatch(beginTime(async (self, symbol, signal, cu
 });
 const CALL_RISK_CHECK_SIGNAL_FN = trycatch(beginTime(async (self, symbol, pendingSignal, currentPrice, timestamp, backtest) => {
     return await ExecutionContextService.runInContext(async () => {
-        return await self.params.risk.checkSignal({
+        return await self.params.risk.checkSignalAndReserve({
             currentSignal: TO_PUBLIC_SIGNAL("scheduled", pendingSignal, currentPrice),
             symbol: symbol,
             strategyName: self.params.method.context.strategyName,
@@ -10558,6 +11790,7 @@ class ClientStrategy {
 }
 
 const RISK_METHOD_NAME_CHECK_SIGNAL = "MergeRisk.checkSignal";
+const RISK_METHOD_NAME_CHECK_SIGNAL_AND_RESERVE = "MergeRisk.checkSignalAndReserve";
 const RISK_METHOD_NAME_ADD_SIGNAL = "MergeRisk.addSignal";
 const RISK_METHOD_NAME_REMOVE_SIGNAL = "MergeRisk.removeSignal";
 /** Logger service injected as DI singleton */
@@ -10616,7 +11849,7 @@ class MergeRisk {
      * @param params - Risk check parameters (symbol, strategy, position, exchange)
      * @returns Promise resolving to true if all risks approve, false if any risk rejects
      */
-    async checkSignal(params) {
+    async checkSignal(params, options = {}) {
         LOGGER_SERVICE$5.info(RISK_METHOD_NAME_CHECK_SIGNAL, {
             params,
         });
@@ -10624,6 +11857,36 @@ class MergeRisk {
             if (await not(risk.checkSignal({
                 ...params,
                 riskName,
+            }, options))) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Concurrency-safe variant of {@link checkSignal} — validates the signal AND
+     * reserves a placeholder in every child risk's active position map atomically.
+     *
+     * Iterates child risks sequentially. On the first rejection it returns false
+     * immediately; child risks checked earlier in the loop are left with their
+     * reservations in place — `removeSignal` on the parent will roll them back
+     * (it propagates to all children unconditionally).
+     *
+     * Use from strategy execution paths where the caller will follow up with
+     * `addSignal` on success. See {@link IRisk.checkSignalAndReserve} for the
+     * full rationale on why reserving inside the lock is necessary.
+     *
+     * @param params - Risk check parameters (symbol, strategy, position, exchange)
+     * @returns Promise resolving to true if all risks approve (and reserved), false if any risk rejects
+     */
+    async checkSignalAndReserve(params) {
+        LOGGER_SERVICE$5.info(RISK_METHOD_NAME_CHECK_SIGNAL_AND_RESERVE, {
+            params,
+        });
+        for (const [riskName, risk] of Object.entries(this._riskMap)) {
+            if (await not(risk.checkSignalAndReserve({
+                ...params,
+                riskName,
             }))) {
                 return false;
             }
@@ -10733,6 +11996,7 @@ const CALL_SIGNAL_EMIT_FN = trycatch(beginTime(async (self, tick, context, isBac
  */
 const NOOP_RISK = {
     checkSignal: () => Promise.resolve(true),
+    checkSignalAndReserve: () => Promise.resolve(true),
     addSignal: () => Promise.resolve(),
     removeSignal: () => Promise.resolve(),
 };
@@ -12908,6 +14172,8 @@ const alignToInterval = (date, interval) => {
     return new Date(Math.floor(date.getTime() / intervalMs) * intervalMs);
 };
 
+/** Used to prevent race confition between concurent strategies */
+const RISK_LOCK = new Lock();
 /** Symbol indicating that positions need to be fetched from persistence */
 const POSITION_NEED_FETCH = Symbol("risk-need-fetch");
 /** Get timestamp from execution context or fallback to aligned current time */
@@ -13093,60 +14359,115 @@ class ClientRisk {
          * @param params - Risk check arguments (passthrough from ClientStrategy)
          * @returns Promise resolving to true if allowed, false if rejected
          */
-        this.checkSignal = async (params) => {
+        this.checkSignal = async (params, options = {}) => {
             this.params.logger.debug("ClientRisk checkSignal", {
                 symbol: params.symbol,
                 strategyName: params.strategyName,
                 backtest: this.params.backtest,
             });
-            if (this._activePositions === POSITION_NEED_FETCH) {
-                await this.waitForInit();
-            }
-            const riskMap = this._activePositions;
-            const timestamp = GET_CONTEXT_TIMESTAMP_FN(this);
-            const payload = {
-                ...params,
-                currentSignal: TO_RISK_SIGNAL(params.currentSignal, params.currentPrice, timestamp),
-                activePositionCount: riskMap.size,
-                activePositions: Array.from(riskMap.values()),
-            };
-            let rejectionResult = null;
-            if (this.params.validations) {
-                for (const validation of this.params.validations) {
-                    const rejection = await DO_VALIDATION_FN(this, typeof validation === "function" ? validation : validation.validate, payload);
-                    if (!rejection) {
-                        continue;
-                    }
-                    if (typeof rejection === "string") {
-                        rejectionResult = {
-                            id: null,
-                            note: rejection
-                                ? rejection
-                                : "note" in validation
-                                    ? validation.note
-                                    : "Validation failed",
-                        };
-                        break;
-                    }
-                    if (isObject(rejection)) {
-                        rejectionResult = {
-                            id: get(rejection, "id") || null,
-                            note: get(rejection, "note") || "Validation rejected the signal",
-                        };
-                        break;
+            await RISK_LOCK.acquireLock();
+            try {
+                if (this._activePositions === POSITION_NEED_FETCH) {
+                    await this.waitForInit();
+                }
+                const riskMap = this._activePositions;
+                const timestamp = GET_CONTEXT_TIMESTAMP_FN(this);
+                const payload = {
+                    ...params,
+                    currentSignal: TO_RISK_SIGNAL(params.currentSignal, params.currentPrice, timestamp),
+                    activePositionCount: riskMap.size,
+                    activePositions: Array.from(riskMap.values()),
+                };
+                let rejectionResult = null;
+                if (this.params.validations) {
+                    for (const validation of this.params.validations) {
+                        const rejection = await DO_VALIDATION_FN(this, typeof validation === "function" ? validation : validation.validate, payload);
+                        if (!rejection) {
+                            continue;
+                        }
+                        if (typeof rejection === "string") {
+                            rejectionResult = {
+                                id: null,
+                                note: rejection
+                                    ? rejection
+                                    : "note" in validation
+                                        ? validation.note
+                                        : "Validation failed",
+                            };
+                            break;
+                        }
+                        if (isObject(rejection)) {
+                            rejectionResult = {
+                                id: get(rejection, "id") || null,
+                                note: get(rejection, "note") || "Validation rejected the signal",
+                            };
+                            break;
+                        }
                     }
                 }
+                if (rejectionResult) {
+                    // Call params.onRejected for riskSubject emission
+                    await this.params.onRejected(params.symbol, params, riskMap.size, rejectionResult, params.timestamp, this.params.backtest);
+                    // Call schema callbacks.onRejected if defined
+                    await CALL_REJECTED_CALLBACKS_FN(this, params.symbol, params);
+                    return false;
+                }
+                // Optional placeholder reservation: when caller plans to addSignal next,
+                // pre-write into riskMap inside the same critical section so concurrent
+                // checkSignal calls observe the incremented size before addSignal lands.
+                // The placeholder shares the same key as the future addSignal — it will
+                // be overwritten with real position data, not duplicated.
+                if (options?.reserve) {
+                    const reserveKey = CREATE_NAME_FN(params.strategyName, params.exchangeName, params.symbol);
+                    const signal = params.currentSignal;
+                    riskMap.set(reserveKey, {
+                        strategyName: params.strategyName,
+                        exchangeName: params.exchangeName,
+                        frameName: params.frameName,
+                        symbol: params.symbol,
+                        position: signal.position,
+                        priceOpen: signal.priceOpen ?? params.currentPrice,
+                        priceStopLoss: signal.priceStopLoss,
+                        priceTakeProfit: signal.priceTakeProfit,
+                        minuteEstimatedTime: signal.minuteEstimatedTime,
+                        openTimestamp: timestamp,
+                    });
+                }
+                // All checks passed
+                await CALL_ALLOWED_CALLBACKS_FN(this, params.symbol, params);
+                return true;
             }
-            if (rejectionResult) {
-                // Call params.onRejected for riskSubject emission
-                await this.params.onRejected(params.symbol, params, riskMap.size, rejectionResult, params.timestamp, this.params.backtest);
-                // Call schema callbacks.onRejected if defined
-                await CALL_REJECTED_CALLBACKS_FN(this, params.symbol, params);
-                return false;
+            finally {
+                await RISK_LOCK.releaseLock();
             }
-            // All checks passed
-            await CALL_ALLOWED_CALLBACKS_FN(this, params.symbol, params);
-            return true;
+        };
+        /**
+         * Concurrency-safe variant of {@link checkSignal}: validates the signal AND
+         * reserves a placeholder slot in the active position map atomically.
+         *
+         * **Why this exists.** `checkSignal` followed later by `addSignal` is not
+         * atomic — between the two calls the caller does signal setup work that
+         * yields to the event loop (sync-open callback, persist writes, etc.). When
+         * several strategies sharing the same risk profile run in parallel, all of
+         * them can pass `checkSignal` while the active position map is still empty,
+         * then each call `addSignal` and blow past the limit. Reserving inside the
+         * lock guarantees the next concurrent caller observes the incremented size
+         * before its own validation runs.
+         *
+         * The reservation uses the same map key as the eventual `addSignal` call
+         * (`strategyName + exchangeName + symbol`), so `addSignal` overwrites the
+         * placeholder rather than appending a duplicate.
+         *
+         * Callers MUST ensure that every successful return is followed by either
+         * `addSignal` (overwrites the placeholder with real data) or `removeSignal`
+         * (clears the placeholder if opening is aborted). Otherwise the riskMap
+         * accumulates stale reservations.
+         *
+         * @param params - Risk check arguments (passthrough from ClientStrategy)
+         * @returns Promise resolving to true if allowed (and reserved), false if rejected (no reservation)
+         */
+        this.checkSignalAndReserve = async (params) => {
+            return await this.checkSignal(params, { reserve: true });
         };
     }
     /**
@@ -13173,24 +14494,30 @@ class ClientRisk {
             positionData,
             backtest: this.params.backtest,
         });
-        if (this._activePositions === POSITION_NEED_FETCH) {
-            await this.waitForInit();
+        await RISK_LOCK.acquireLock();
+        try {
+            if (this._activePositions === POSITION_NEED_FETCH) {
+                await this.waitForInit();
+            }
+            const key = CREATE_NAME_FN(context.strategyName, context.exchangeName, symbol);
+            const riskMap = this._activePositions;
+            riskMap.set(key, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+                symbol,
+                position: positionData.position,
+                priceOpen: positionData.priceOpen,
+                priceStopLoss: positionData.priceStopLoss,
+                priceTakeProfit: positionData.priceTakeProfit,
+                minuteEstimatedTime: positionData.minuteEstimatedTime,
+                openTimestamp: positionData.openTimestamp,
+            });
+            await this._updatePositions();
+        }
+        finally {
+            await RISK_LOCK.releaseLock();
         }
-        const key = CREATE_NAME_FN(context.strategyName, context.exchangeName, symbol);
-        const riskMap = this._activePositions;
-        riskMap.set(key, {
-            strategyName: context.strategyName,
-            exchangeName: context.exchangeName,
-            frameName: context.frameName,
-            symbol,
-            position: positionData.position,
-            priceOpen: positionData.priceOpen,
-            priceStopLoss: positionData.priceStopLoss,
-            priceTakeProfit: positionData.priceTakeProfit,
-            minuteEstimatedTime: positionData.minuteEstimatedTime,
-            openTimestamp: positionData.openTimestamp,
-        });
-        await this._updatePositions();
     }
     /**
      * Removes a closed signal.
@@ -13202,13 +14529,19 @@ class ClientRisk {
             context,
             backtest: this.params.backtest,
         });
-        if (this._activePositions === POSITION_NEED_FETCH) {
-            await this.waitForInit();
+        await RISK_LOCK.acquireLock();
+        try {
+            if (this._activePositions === POSITION_NEED_FETCH) {
+                await this.waitForInit();
+            }
+            const key = CREATE_NAME_FN(context.strategyName, context.exchangeName, symbol);
+            const riskMap = this._activePositions;
+            riskMap.delete(key);
+            await this._updatePositions();
+        }
+        finally {
+            await RISK_LOCK.releaseLock();
         }
-        const key = CREATE_NAME_FN(context.strategyName, context.exchangeName, symbol);
-        const riskMap = this._activePositions;
-        riskMap.delete(key);
-        await this._updatePositions();
     }
 }
 
@@ -13343,12 +14676,33 @@ class RiskConnectionService {
          * @param payload - Execution payload with risk name, exchangeName, frameName and backtest mode
          * @returns Promise resolving to risk check result
          */
-        this.checkSignal = async (params, payload) => {
+        this.checkSignal = async (params, payload, options = {}) => {
             this.loggerService.log("riskConnectionService checkSignal", {
                 symbol: params.symbol,
                 payload,
             });
-            return await this.getRisk(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest).checkSignal(params);
+            return await this.getRisk(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest).checkSignal(params, options);
+        };
+        /**
+         * Concurrency-safe variant of {@link checkSignal} — validates the signal AND
+         * reserves a placeholder in the active position map atomically.
+         *
+         * Routes to the same ClientRisk instance as {@link checkSignal} but delegates
+         * to its `checkSignalAndReserve` method. Use from execution paths where the
+         * caller will follow up with `addSignal` on success — guarantees concurrent
+         * callers cannot all pass validation against a stale empty map. See
+         * {@link IRisk.checkSignalAndReserve} for the full rationale.
+         *
+         * @param params - Risk check arguments (portfolio state, position details)
+         * @param payload - Execution payload with risk name, exchangeName, frameName and backtest mode
+         * @returns Promise resolving to true if allowed (and reserved), false if rejected (no reservation)
+         */
+        this.checkSignalAndReserve = async (params, payload) => {
+            this.loggerService.log("riskConnectionService checkSignalAndReserve", {
+                symbol: params.symbol,
+                payload,
+            });
+            return await this.getRisk(payload.riskName, payload.exchangeName, payload.frameName, payload.backtest).checkSignalAndReserve(params);
         };
         /**
          * Registers an opened signal with the risk management system.
@@ -16552,13 +17906,34 @@ class RiskGlobalService {
          * @param payload - Execution payload with risk name, exchangeName, frameName and backtest mode
          * @returns Promise resolving to risk check result
          */
-        this.checkSignal = async (params, payload) => {
+        this.checkSignal = async (params, payload, options = {}) => {
             this.loggerService.log("riskGlobalService checkSignal", {
                 symbol: params.symbol,
                 payload,
             });
             await this.validate(payload);
-            return await this.riskConnectionService.checkSignal(params, payload);
+            return await this.riskConnectionService.checkSignal(params, payload, options);
+        };
+        /**
+         * Concurrency-safe variant of {@link checkSignal} — validates the signal AND
+         * reserves a placeholder in the active position map atomically.
+         *
+         * Use from strategy execution paths where the caller will follow up with
+         * `addSignal` on success — guarantees concurrent callers cannot all pass
+         * validation against a stale empty map. See {@link IRisk.checkSignalAndReserve}
+         * for the full rationale.
+         *
+         * @param params - Risk check arguments (portfolio state, position details)
+         * @param payload - Execution payload with risk name, exchangeName, frameName and backtest mode
+         * @returns Promise resolving to true if allowed (and reserved), false if rejected (no reservation)
+         */
+        this.checkSignalAndReserve = async (params, payload) => {
+            this.loggerService.log("riskGlobalService checkSignalAndReserve", {
+                symbol: params.symbol,
+                payload,
+            });
+            await this.validate(payload);
+            return await this.riskConnectionService.checkSignalAndReserve(params, payload);
         };
         /**
          * Registers an opened signal with the risk management system.
@@ -61924,4 +63299,4 @@ const validateSignal = (signal, currentPrice) => {
     return !errors.length;
 };
 
-export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistIntervalAdapter, PersistLogAdapter, PersistMeasureAdapter, PersistMemoryAdapter, PersistNotificationAdapter, PersistPartialAdapter, PersistRecentAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSessionAdapter, PersistSignalAdapter, PersistStateAdapter, PersistStorageAdapter, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };
+export { ActionBase, Backtest, Breakeven, Broker, BrokerBase, Cache, Constant, Dump, Exchange, ExecutionContextService, Heat, HighestProfit, Interval, Live, Log, Markdown, MarkdownFileBase, MarkdownFolderBase, MarkdownWriter, MaxDrawdown, Memory, MemoryBacktest, MemoryBacktestAdapter, MemoryLive, MemoryLiveAdapter, MethodContextService, Notification, NotificationBacktest, NotificationLive, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistBreakevenInstance, PersistCandleAdapter, PersistCandleInstance, PersistIntervalAdapter, PersistIntervalInstance, PersistLogAdapter, PersistLogInstance, PersistMeasureAdapter, PersistMeasureInstance, PersistMemoryAdapter, PersistMemoryInstance, PersistNotificationAdapter, PersistNotificationInstance, PersistPartialAdapter, PersistPartialInstance, PersistRecentAdapter, PersistRecentInstance, PersistRiskAdapter, PersistRiskInstance, PersistScheduleAdapter, PersistScheduleInstance, PersistSessionAdapter, PersistSessionInstance, PersistSignalAdapter, PersistSignalInstance, PersistStateAdapter, PersistStateInstance, PersistStorageAdapter, PersistStorageInstance, Position, PositionSize, Recent, RecentBacktest, RecentLive, Reflect$1 as Reflect, Report, ReportBase, ReportWriter, Risk, Schedule, Session, SessionBacktest, SessionLive, State, StateBacktest, StateBacktestAdapter, StateLive, StateLiveAdapter, Storage, StorageBacktest, StorageLive, Strategy, Sync, System, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, alignToInterval, checkCandles, commitActivateScheduled, commitAverageBuy, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialLossCost, commitPartialProfit, commitPartialProfitCost, commitSignalNotify, commitTrailingStop, commitTrailingStopCost, commitTrailingTake, commitTrailingTakeCost, createSignalState, dumpAgentAnswer, dumpError, dumpJson, dumpRecord, dumpTable, dumpText, emitters, formatPrice, formatQuantity, get, getActionSchema, getAggregatedTrades, getAveragePrice, getBacktestTimeframe, getBreakeven, getCandles, getClosePrice, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getEffectivePriceOpen, getExchangeSchema, getFrameSchema, getLatestSignal, getMaxDrawdownDistancePnlCost, getMaxDrawdownDistancePnlPercentage, getMinutesSinceLatestSignalCreated, getMode, getNextCandles, getOrderBook, getPendingSignal, getPositionActiveMinutes, getPositionCountdownMinutes, getPositionDrawdownMinutes, getPositionEffectivePrice, getPositionEntries, getPositionEntryOverlap, getPositionEstimateMinutes, getPositionHighestMaxDrawdownPnlCost, getPositionHighestMaxDrawdownPnlPercentage, getPositionHighestPnlCost, getPositionHighestPnlPercentage, getPositionHighestProfitBreakeven, getPositionHighestProfitDistancePnlCost, getPositionHighestProfitDistancePnlPercentage, getPositionHighestProfitMinutes, getPositionHighestProfitPrice, getPositionHighestProfitTimestamp, getPositionInvestedCost, getPositionInvestedCount, getPositionLevels, getPositionMaxDrawdownMinutes, getPositionMaxDrawdownPnlCost, getPositionMaxDrawdownPnlPercentage, getPositionMaxDrawdownPrice, getPositionMaxDrawdownTimestamp, getPositionPartialOverlap, getPositionPartials, getPositionPnlCost, getPositionPnlPercent, getPositionWaitingMinutes, getRawCandles, getRiskSchema, getScheduledSignal, getSessionData, getSignalState, getSizingSchema, getStrategySchema, getSymbol, getTimestamp, getTotalClosed, getTotalCostClosed, getTotalPercentClosed, getWalkerSchema, hasNoPendingSignal, hasNoScheduledSignal, hasTradeContext, investedCostToPercent, backtest as lib, listExchangeSchema, listFrameSchema, listMemory, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenHighestProfit, listenHighestProfitOnce, listenIdlePing, listenIdlePingOnce, listenMaxDrawdown, listenMaxDrawdownOnce, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalNotify, listenSignalNotifyOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenSync, listenSyncOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, percentDiff, percentToCloseCost, percentValue, readMemory, removeMemory, roundTicks, runInMockContext, searchMemory, set, setColumns, setConfig, setLogger, setSessionData, setSignalState, shutdown, slPercentShiftToPrice, slPriceToPercentShift, stopStrategy, toProfitLossDto, tpPercentShiftToPrice, tpPriceToPercentShift, validate, validateCommonSignal, validatePendingSignal, validateScheduledSignal, validateSignal, waitForCandle, warmCandles, writeMemory };