backtest-kit 2.0.12 → 2.1.2

package/build/index.cjs

@@ -586,1119 +586,899 @@ var emitters = /*#__PURE__*/Object.freeze({
     walkerStopSubject: walkerStopSubject
 });
 
-const INTERVAL_MINUTES$4 = {
-    "1m": 1,
-    "3m": 3,
-    "5m": 5,
-    "15m": 15,
-    "30m": 30,
-    "1h": 60,
-    "2h": 120,
-    "4h": 240,
-    "6h": 360,
-    "8h": 480,
-};
+const IS_WINDOWS = os.platform() === "win32";
 /**
- * Validates that all candles have valid OHLCV data without anomalies.
- * Detects incomplete candles from Binance API by checking for abnormally low prices or volumes.
- * Incomplete candles often have prices like 0.1 instead of normal 100,000 or zero volume.
+ * Atomically writes data to a file, ensuring the operation either fully completes or leaves the original file unchanged.
+ * Uses a temporary file with a rename strategy on POSIX systems for atomicity, or direct writing with sync on Windows (or when POSIX rename is skipped).
  *
- * @param candles - Array of candle data to validate
- * @throws Error if any candles have anomalous OHLCV values
- */
-const VALIDATE_NO_INCOMPLETE_CANDLES_FN = (candles) => {
-    if (candles.length === 0) {
-        return;
+ *
+ * @param {string} file - The file parameter.
+ * @param {string | Buffer} data - The data to be processed or validated.
+ * @param {Options | BufferEncoding} options - The options parameter (optional).
+ * @throws {Error} Throws an error if the write, sync, or rename operation fails, after attempting cleanup of temporary files.
+ *
+ * @example
+ * // Basic usage with default options
+ * await writeFileAtomic("output.txt", "Hello, world!");
+ * // Writes "Hello, world!" to "output.txt" atomically
+ *
+ * @example
+ * // Custom options and Buffer data
+ * const buffer = Buffer.from("Binary data");
+ * await writeFileAtomic("data.bin", buffer, { encoding: "binary", mode: 0o644, tmpPrefix: "temp-" });
+ * // Writes binary data to "data.bin" with custom permissions and temp prefix
+ *
+ * @example
+ * // Using encoding shorthand
+ * await writeFileAtomic("log.txt", "Log entry", "utf16le");
+ * // Writes "Log entry" to "log.txt" in UTF-16LE encoding
+ *
+ * @remarks
+ * This function ensures atomicity to prevent partial writes:
+ * - On POSIX systems (non-Windows, unless `GLOBAL_CONFIG.CC_SKIP_POSIX_RENAME` is true):
+ *   - Writes data to a temporary file (e.g., `.tmp-<random>-filename`) in the same directory.
+ *   - Uses `crypto.randomBytes` to generate a unique temporary name, reducing collision risk.
+ *   - Syncs the data to disk and renames the temporary file to the target file atomically with `fs.rename`.
+ *   - Cleans up the temporary file on failure, swallowing cleanup errors to prioritize throwing the original error.
+ * - On Windows (or when POSIX rename is skipped):
+ *   - Writes directly to the target file, syncing data to disk to minimize corruption risk (though not fully atomic).
+ *   - Closes the file handle on failure without additional cleanup.
+ * - Accepts `options` as an object or a string (interpreted as `encoding`), defaulting to `{ encoding: "utf8", mode: 0o666, tmpPrefix: ".tmp-" }`.
+ * Useful in the agent swarm system for safely writing configuration files, logs, or state data where partial writes could cause corruption.
+ *
+ * @see {@link https://nodejs.org/api/fs.html#fspromiseswritefilefile-data-options|fs.promises.writeFile} for file writing details.
+ * @see {@link https://nodejs.org/api/crypto.html#cryptorandombytessize-callback|crypto.randomBytes} for temporary file naming.
+ * @see {@link ../config/params|GLOBAL_CONFIG} for configuration impacting POSIX behavior.
+*/
+async function writeFileAtomic(file, data, options = {}) {
+    if (typeof options === "string") {
+        options = { encoding: options };
     }
-    // Calculate reference price (median or average depending on candle count)
-    const allPrices = candles.flatMap((c) => [c.open, c.high, c.low, c.close]);
-    const validPrices = allPrices.filter(p => p > 0);
-    let referencePrice;
-    if (candles.length >= GLOBAL_CONFIG.CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN) {
-        // Use median for reliable statistics with enough data
-        const sortedPrices = [...validPrices].sort((a, b) => a - b);
-        referencePrice = sortedPrices[Math.floor(sortedPrices.length / 2)] || 0;
+    else if (!options) {
+        options = {};
     }
-    else {
-        // Use average for small datasets (more stable than median)
-        const sum = validPrices.reduce((acc, p) => acc + p, 0);
-        referencePrice = validPrices.length > 0 ? sum / validPrices.length : 0;
+    const { encoding = "utf8", mode = 0o666, tmpPrefix = ".tmp-" } = options;
+    let fileHandle = null;
+    if (IS_WINDOWS) {
+        try {
+            // Create and write to temporary file
+            fileHandle = await fs.open(file, "w", mode);
+            // Write data to the temp file
+            await fileHandle.writeFile(data, { encoding });
+            // Ensure data is flushed to disk
+            await fileHandle.sync();
+            // Close the file before rename
+            await fileHandle.close();
+        }
+        catch (error) {
+            // Clean up if something went wrong
+            if (fileHandle) {
+                await fileHandle.close().catch(() => { });
+            }
+            throw error; // Re-throw the original error
+        }
+        return;
     }
-    if (referencePrice === 0) {
-        throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: cannot calculate reference price (all prices are zero)`);
+    // Create a temporary filename in the same directory
+    const dir = path.dirname(file);
+    const filename = path.basename(file);
+    const tmpFile = path.join(dir, `${tmpPrefix}${crypto.randomBytes(6).toString("hex")}-${filename}`);
+    try {
+        // Create and write to temporary file
+        fileHandle = await fs.open(tmpFile, "w", mode);
+        // Write data to the temp file
+        await fileHandle.writeFile(data, { encoding });
+        // Ensure data is flushed to disk
+        await fileHandle.sync();
+        // Close the file before rename
+        await fileHandle.close();
+        fileHandle = null;
+        // Atomically replace the target file with our temp file
+        await fs.rename(tmpFile, file);
     }
-    const minValidPrice = referencePrice / GLOBAL_CONFIG.CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR;
-    for (let i = 0; i < candles.length; i++) {
-        const candle = candles[i];
-        // Check for invalid numeric values
-        if (!Number.isFinite(candle.open) ||
-            !Number.isFinite(candle.high) ||
-            !Number.isFinite(candle.low) ||
-            !Number.isFinite(candle.close) ||
-            !Number.isFinite(candle.volume) ||
-            !Number.isFinite(candle.timestamp)) {
-            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has invalid numeric values (NaN or Infinity)`);
+    catch (error) {
+        // Clean up if something went wrong
+        if (fileHandle) {
+            await fileHandle.close().catch(() => { });
         }
-        // Check for negative values
-        if (candle.open <= 0 ||
-            candle.high <= 0 ||
-            candle.low <= 0 ||
-            candle.close <= 0 ||
-            candle.volume < 0) {
-            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has zero or negative values`);
+        // Try to remove the temporary file
+        try {
+            await fs.unlink(tmpFile).catch(() => { });
         }
-        // Check for anomalously low prices (incomplete candle indicator)
-        if (candle.open < minValidPrice ||
-            candle.high < minValidPrice ||
-            candle.low < minValidPrice ||
-            candle.close < minValidPrice) {
-            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has anomalously low price. ` +
-                `OHLC: [${candle.open}, ${candle.high}, ${candle.low}, ${candle.close}], ` +
-                `reference: ${referencePrice}, threshold: ${minValidPrice}`);
+        catch (_) {
+            // Ignore errors during cleanup
         }
+        throw error;
     }
-};
-/**
- * Retries the getCandles function with specified retry count and delay.
- * @param dto - Data transfer object containing symbol, interval, and limit
- * @param since - Date object representing the start time for fetching candles
- * @param self - Instance of ClientExchange
- * @returns Promise resolving to array of candle data
- */
-const GET_CANDLES_FN = async (dto, since, self) => {
-    let lastError;
-    for (let i = 0; i !== GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_COUNT; i++) {
+}
+
+var _a$2;
+const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
+const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER = "PersistSignalUtils.usePersistSignalAdapter";
+const PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA = "PersistSignalUtils.readSignalData";
+const PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistSignalUtils.writeSignalData";
+const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON = "PersistSignalUtils.useJson";
+const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY = "PersistSignalUtils.useDummy";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER = "PersistScheduleUtils.usePersistScheduleAdapter";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA = "PersistScheduleUtils.readScheduleData";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA = "PersistScheduleUtils.writeScheduleData";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON = "PersistScheduleUtils.useJson";
+const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY = "PersistScheduleUtils.useDummy";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER = "PersistPartialUtils.usePersistPartialAdapter";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA = "PersistPartialUtils.readPartialData";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistPartialUtils.writePartialData";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON = "PersistPartialUtils.useJson";
+const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY = "PersistPartialUtils.useDummy";
+const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER = "PersistBreakevenUtils.usePersistBreakevenAdapter";
+const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA = "PersistBreakevenUtils.readBreakevenData";
+const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA = "PersistBreakevenUtils.writeBreakevenData";
+const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON = "PersistBreakevenUtils.useJson";
+const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY = "PersistBreakevenUtils.useDummy";
+const PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER = "PersistRiskUtils.usePersistRiskAdapter";
+const PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA = "PersistRiskUtils.readPositionData";
+const PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA = "PersistRiskUtils.writePositionData";
+const PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON = "PersistRiskUtils.useJson";
+const PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY = "PersistRiskUtils.useDummy";
+const PERSIST_BASE_METHOD_NAME_CTOR = "PersistBase.CTOR";
+const PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT = "PersistBase.waitForInit";
+const PERSIST_BASE_METHOD_NAME_READ_VALUE = "PersistBase.readValue";
+const PERSIST_BASE_METHOD_NAME_WRITE_VALUE = "PersistBase.writeValue";
+const PERSIST_BASE_METHOD_NAME_HAS_VALUE = "PersistBase.hasValue";
+const PERSIST_BASE_METHOD_NAME_KEYS = "PersistBase.keys";
+const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
+const BASE_UNLINK_RETRY_COUNT = 5;
+const BASE_UNLINK_RETRY_DELAY = 1000;
+const BASE_WAIT_FOR_INIT_FN = async (self) => {
+    bt.loggerService.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
+        entityName: self.entityName,
+        directory: self._directory,
+    });
+    await fs.mkdir(self._directory, { recursive: true });
+    for await (const key of self.keys()) {
         try {
-            const result = await self.params.getCandles(dto.symbol, dto.interval, since, dto.limit, self.params.execution.context.backtest);
-            VALIDATE_NO_INCOMPLETE_CANDLES_FN(result);
-            return result;
+            await self.readValue(key);
         }
-        catch (err) {
-            const message = `ClientExchange GET_CANDLES_FN: attempt ${i + 1} failed for symbol=${dto.symbol}, interval=${dto.interval}, since=${since.toISOString()}, limit=${dto.limit}}`;
-            const payload = {
-                error: functoolsKit.errorData(err),
-                message: functoolsKit.getErrorMessage(err),
-            };
-            self.params.logger.warn(message, payload);
-            console.warn(message, payload);
-            lastError = err;
-            await functoolsKit.sleep(GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS);
+        catch {
+            const filePath = self._getFilePath(key);
+            console.error(`backtest-kit PersistBase found invalid document for filePath=${filePath} entityName=${self.entityName}`);
+            if (await functoolsKit.not(BASE_WAIT_FOR_INIT_UNLINK_FN(filePath))) {
+                console.error(`backtest-kit PersistBase failed to remove invalid document for filePath=${filePath} entityName=${self.entityName}`);
+            }
         }
     }
-    throw lastError;
 };
+const BASE_WAIT_FOR_INIT_UNLINK_FN = async (filePath) => functoolsKit.trycatch(functoolsKit.retry(async () => {
+    try {
+        await fs.unlink(filePath);
+        return true;
+    }
+    catch (error) {
+        console.error(`backtest-kit PersistBase unlink failed for filePath=${filePath} error=${functoolsKit.getErrorMessage(error)}`);
+        throw error;
+    }
+}, BASE_UNLINK_RETRY_COUNT, BASE_UNLINK_RETRY_DELAY), {
+    defaultValue: false,
+});
 /**
- * Wrapper to call onCandleData callback with error handling.
- * Catches and logs any errors thrown by the user-provided callback.
- *
- * @param self - ClientExchange instance reference
- * @param symbol - Trading pair symbol
- * @param interval - Candle interval
- * @param since - Start date for candle data
- * @param limit - Number of candles
- * @param data - Array of candle data
- */
-const CALL_CANDLE_DATA_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, interval, since, limit, data) => {
-    if (self.params.callbacks?.onCandleData) {
-        await self.params.callbacks.onCandleData(symbol, interval, since, limit, data);
-    }
-}, {
-    fallback: (error) => {
-        const message = "ClientExchange CALL_CANDLE_DATA_CALLBACKS_FN thrown";
-        const payload = {
-            error: functoolsKit.errorData(error),
-            message: functoolsKit.getErrorMessage(error),
-        };
-        bt.loggerService.warn(message, payload);
-        console.warn(message, payload);
-        errorEmitter.next(error);
-    },
-});
-/**
- * Client implementation for exchange data access.
+ * Base class for file-based persistence with atomic writes.
  *
  * Features:
- * - Historical candle fetching (backwards from execution context)
- * - Future candle fetching (forwards for backtest)
- * - VWAP calculation from last 5 1m candles
- * - Price/quantity formatting for exchange
- *
- * All methods use prototype functions for memory efficiency.
+ * - Atomic file writes using writeFileAtomic
+ * - Auto-validation and cleanup of corrupted files
+ * - Async generator support for iteration
+ * - Retry logic for file deletion
  *
  * @example
  * ```typescript
- * const exchange = new ClientExchange({
- *   exchangeName: "binance",
- *   getCandles: async (symbol, interval, since, limit) => [...],
- *   formatPrice: async (symbol, price) => price.toFixed(2),
- *   formatQuantity: async (symbol, quantity) => quantity.toFixed(8),
- *   execution: executionService,
- *   logger: loggerService,
- * });
- *
- * const candles = await exchange.getCandles("BTCUSDT", "1m", 100);
- * const vwap = await exchange.getAveragePrice("BTCUSDT");
+ * const persist = new PersistBase("my-entity", "./data");
+ * await persist.waitForInit(true);
+ * await persist.writeValue("key1", { data: "value" });
+ * const value = await persist.readValue("key1");
  * ```
  */
-class ClientExchange {
-    constructor(params) {
-        this.params = params;
-    }
+class PersistBase {
     /**
-     * Fetches historical candles backwards from execution context time.
+     * Creates new persistence instance.
      *
-     * @param symbol - Trading pair symbol
-     * @param interval - Candle interval
-     * @param limit - Number of candles to fetch
-     * @returns Promise resolving to array of candles
+     * @param entityName - Unique entity type identifier
+     * @param baseDir - Base directory for all entities (default: ./dump/data)
      */
-    async getCandles(symbol, interval, limit) {
-        this.params.logger.debug(`ClientExchange getCandles`, {
-            symbol,
-            interval,
-            limit,
+    constructor(entityName, baseDir = path.join(process.cwd(), "logs/data")) {
+        this.entityName = entityName;
+        this.baseDir = baseDir;
+        this[_a$2] = functoolsKit.singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
+            entityName: this.entityName,
+            baseDir,
         });
-        const step = INTERVAL_MINUTES$4[interval];
-        const adjust = step * limit;
-        if (!adjust) {
-            throw new Error(`ClientExchange unknown time adjust for interval=${interval}`);
-        }
-        const since = new Date(this.params.execution.context.when.getTime() - adjust * 60 * 1000);
-        let allData = [];
-        // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
-        if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
-            let remaining = limit;
-            let currentSince = new Date(since.getTime());
-            while (remaining > 0) {
-                const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
-                const chunkData = await GET_CANDLES_FN({ symbol, interval, limit: chunkLimit }, currentSince, this);
-                allData.push(...chunkData);
-                remaining -= chunkLimit;
-                if (remaining > 0) {
-                    // Move currentSince forward by the number of candles fetched
-                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * 60 * 1000);
-                }
-            }
-        }
-        else {
-            allData = await GET_CANDLES_FN({ symbol, interval, limit }, since, this);
-        }
-        // Filter candles to strictly match the requested range
-        const whenTimestamp = this.params.execution.context.when.getTime();
-        const sinceTimestamp = since.getTime();
-        const stepMs = step * 60 * 1000;
-        const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp < whenTimestamp + stepMs);
-        // Apply distinct by timestamp to remove duplicates
-        const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
-        if (filteredData.length !== uniqueData.length) {
-            const msg = `ClientExchange Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`;
-            this.params.logger.warn(msg);
-            console.warn(msg);
-        }
-        if (uniqueData.length < limit) {
-            const msg = `ClientExchange Expected ${limit} candles, got ${uniqueData.length}`;
-            this.params.logger.warn(msg);
-            console.warn(msg);
-        }
-        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, uniqueData);
-        return uniqueData;
+        this._directory = path.join(this.baseDir, this.entityName);
     }
     /**
-     * Fetches future candles forwards from execution context time.
-     * Used in backtest mode to get candles for signal duration.
+     * Computes file path for entity ID.
      *
-     * @param symbol - Trading pair symbol
-     * @param interval - Candle interval
-     * @param limit - Number of candles to fetch
-     * @returns Promise resolving to array of candles
-     * @throws Error if trying to fetch future candles in live mode
+     * @param entityId - Entity identifier
+     * @returns Full file path to entity JSON file
      */
-    async getNextCandles(symbol, interval, limit) {
-        this.params.logger.debug(`ClientExchange getNextCandles`, {
-            symbol,
-            interval,
-            limit,
+    _getFilePath(entityId) {
+        return path.join(this.baseDir, this.entityName, `${entityId}.json`);
+    }
+    async waitForInit(initial) {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
+            entityName: this.entityName,
+            initial,
         });
-        const since = new Date(this.params.execution.context.when.getTime());
-        const now = Date.now();
-        // Вычисляем конечное время запроса
-        const step = INTERVAL_MINUTES$4[interval];
-        const endTime = since.getTime() + limit * step * 60 * 1000;
-        // Проверяем что запрошенный период не заходит за Date.now()
-        if (endTime > now) {
-            return [];
+        await this[BASE_WAIT_FOR_INIT_SYMBOL]();
+    }
+    async readValue(entityId) {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
+            entityName: this.entityName,
+            entityId,
+        });
+        try {
+            const filePath = this._getFilePath(entityId);
+            const fileContent = await fs.readFile(filePath, "utf-8");
+            return JSON.parse(fileContent);
         }
-        let allData = [];
-        // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
-        if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
-            let remaining = limit;
-            let currentSince = new Date(since.getTime());
-            while (remaining > 0) {
-                const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
-                const chunkData = await GET_CANDLES_FN({ symbol, interval, limit: chunkLimit }, currentSince, this);
-                allData.push(...chunkData);
-                remaining -= chunkLimit;
-                if (remaining > 0) {
-                    // Move currentSince forward by the number of candles fetched
-                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * 60 * 1000);
-                }
+        catch (error) {
+            if (error?.code === "ENOENT") {
+                throw new Error(`Entity ${this.entityName}:${entityId} not found`);
             }
+            throw new Error(`Failed to read entity ${this.entityName}:${entityId}: ${functoolsKit.getErrorMessage(error)}`);
         }
-        else {
-            allData = await GET_CANDLES_FN({ symbol, interval, limit }, since, this);
-        }
-        // Filter candles to strictly match the requested range
-        const sinceTimestamp = since.getTime();
-        const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp < endTime);
-        // Apply distinct by timestamp to remove duplicates
-        const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
-        if (filteredData.length !== uniqueData.length) {
-            const msg = `ClientExchange getNextCandles: Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`;
-            this.params.logger.warn(msg);
-            console.warn(msg);
+    }
+    async hasValue(entityId) {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
+            entityName: this.entityName,
+            entityId,
+        });
+        try {
+            const filePath = this._getFilePath(entityId);
+            await fs.access(filePath);
+            return true;
         }
-        if (uniqueData.length < limit) {
-            const msg = `ClientExchange getNextCandles: Expected ${limit} candles, got ${uniqueData.length}`;
-            this.params.logger.warn(msg);
-            console.warn(msg);
+        catch (error) {
+            if (error?.code === "ENOENT") {
+                return false;
+            }
+            throw new Error(`Failed to check existence of entity ${this.entityName}:${entityId}: ${functoolsKit.getErrorMessage(error)}`);
         }
-        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, uniqueData);
-        return uniqueData;
     }
-    /**
-     * Calculates VWAP (Volume Weighted Average Price) from last N 1m candles.
-     * The number of candles is configurable via GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT.
-     *
-     * Formula:
-     * - Typical Price = (high + low + close) / 3
-     * - VWAP = sum(typical_price * volume) / sum(volume)
-     *
-     * If volume is zero, returns simple average of close prices.
-     *
-     * @param symbol - Trading pair symbol
-     * @returns Promise resolving to VWAP price
-     * @throws Error if no candles available
-     */
-    async getAveragePrice(symbol) {
-        this.params.logger.debug(`ClientExchange getAveragePrice`, {
-            symbol,
+    async writeValue(entityId, entity) {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
+            entityName: this.entityName,
+            entityId,
         });
-        const candles = await this.getCandles(symbol, "1m", GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT);
-        if (candles.length === 0) {
-            throw new Error(`ClientExchange getAveragePrice: no candles data for symbol=${symbol}`);
+        try {
+            const filePath = this._getFilePath(entityId);
+            const serializedData = JSON.stringify(entity);
+            await writeFileAtomic(filePath, serializedData, "utf-8");
         }
-        // VWAP (Volume Weighted Average Price)
-        // Используем типичную цену (typical price) = (high + low + close) / 3
-        const sumPriceVolume = candles.reduce((acc, candle) => {
-            const typicalPrice = (candle.high + candle.low + candle.close) / 3;
-            return acc + typicalPrice * candle.volume;
-        }, 0);
-        const totalVolume = candles.reduce((acc, candle) => acc + candle.volume, 0);
-        if (totalVolume === 0) {
-            // Если объем нулевой, возвращаем простое среднее close цен
-            const sum = candles.reduce((acc, candle) => acc + candle.close, 0);
-            return sum / candles.length;
+        catch (error) {
+            throw new Error(`Failed to write entity ${this.entityName}:${entityId}: ${functoolsKit.getErrorMessage(error)}`);
         }
-        const vwap = sumPriceVolume / totalVolume;
-        return vwap;
     }
     /**
-     * Formats quantity according to exchange-specific rules for the given symbol.
-     * Applies proper decimal precision and rounding based on symbol's lot size filters.
+     * Async generator yielding all entity IDs.
+     * Sorted alphanumerically.
+     * Used internally by waitForInit for validation.
      *
-     * @param symbol - Trading pair symbol
-     * @param quantity - Raw quantity to format
-     * @returns Promise resolving to formatted quantity as string
+     * @returns AsyncGenerator yielding entity IDs
+     * @throws Error if reading fails
      */
-    async formatQuantity(symbol, quantity) {
-        this.params.logger.debug("binanceService formatQuantity", {
-            symbol,
-            quantity,
+    async *keys() {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
+            entityName: this.entityName,
         });
-        return await this.params.formatQuantity(symbol, quantity, this.params.execution.context.backtest);
+        try {
+            const files = await fs.readdir(this._directory);
+            const entityIds = files
+                .filter((file) => file.endsWith(".json"))
+                .map((file) => file.slice(0, -5))
+                .sort((a, b) => a.localeCompare(b, undefined, {
+                numeric: true,
+                sensitivity: "base",
+            }));
+            for (const entityId of entityIds) {
+                yield entityId;
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to read keys for ${this.entityName}: ${functoolsKit.getErrorMessage(error)}`);
+        }
     }
+}
+_a$2 = BASE_WAIT_FOR_INIT_SYMBOL;
+// @ts-ignore
+PersistBase = functoolsKit.makeExtendable(PersistBase);
+/**
+ * Dummy persist adapter that discards all writes.
+ * Used for disabling persistence.
+ */
+class PersistDummy {
     /**
-     * Formats price according to exchange-specific rules for the given symbol.
-     * Applies proper decimal precision and rounding based on symbol's price filters.
-     *
-     * @param symbol - Trading pair symbol
-     * @param price - Raw price to format
-     * @returns Promise resolving to formatted price as string
+     * No-op initialization function.
+     * @returns Promise that resolves immediately
      */
-    async formatPrice(symbol, price) {
-        this.params.logger.debug("binanceService formatPrice", {
-            symbol,
-            price,
-        });
-        return await this.params.formatPrice(symbol, price, this.params.execution.context.backtest);
+    async waitForInit() {
     }
     /**
-     * Fetches order book for a trading pair.
-     *
-     * Calculates time range based on execution context time (when) and
-     * CC_ORDER_BOOK_TIME_OFFSET_MINUTES, then delegates to the exchange
-     * schema implementation which may use or ignore the time range.
-     *
-     * @param symbol - Trading pair symbol
-     * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
-     * @returns Promise resolving to order book data
-     * @throws Error if getOrderBook is not implemented
+     * No-op read function.
+     * @returns Promise that resolves with empty object
      */
-    async getOrderBook(symbol, depth = GLOBAL_CONFIG.CC_ORDER_BOOK_MAX_DEPTH_LEVELS) {
-        this.params.logger.debug("ClientExchange getOrderBook", {
-            symbol,
-            depth,
-        });
-        const to = new Date(this.params.execution.context.when.getTime());
-        const from = new Date(to.getTime() - GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * 60 * 1000);
-        return await this.params.getOrderBook(symbol, depth, from, to, this.params.execution.context.backtest);
+    async readValue() {
+        return {};
+    }
+    /**
+     * No-op has value check.
+     * @returns Promise that resolves to false
+     */
+    async hasValue() {
+        return false;
+    }
+    /**
+     * No-op write function.
+     * @returns Promise that resolves immediately
+     */
+    async writeValue() {
+    }
+    /**
+     * No-op keys generator.
+     * @returns Empty async generator
+     */
+    async *keys() {
+        // Empty generator - no keys
     }
 }
-
-/**
- * Default implementation for getCandles.
- * Throws an error indicating the method is not implemented.
- */
-const DEFAULT_GET_CANDLES_FN$1 = async (_symbol, _interval, _since, _limit, _backtest) => {
-    throw new Error(`getCandles is not implemented for this exchange`);
-};
-/**
- * Default implementation for formatQuantity.
- * Returns Bitcoin precision on Binance (8 decimal places).
- */
-const DEFAULT_FORMAT_QUANTITY_FN$1 = async (_symbol, quantity, _backtest) => {
-    return quantity.toFixed(8);
-};
-/**
- * Default implementation for formatPrice.
- * Returns Bitcoin precision on Binance (2 decimal places).
- */
-const DEFAULT_FORMAT_PRICE_FN$1 = async (_symbol, price, _backtest) => {
-    return price.toFixed(2);
-};
-/**
- * Default implementation for getOrderBook.
- * Throws an error indicating the method is not implemented.
- *
- * @param _symbol - Trading pair symbol (unused)
- * @param _depth - Maximum depth levels (unused)
- * @param _from - Start of time range (unused - can be ignored in live implementations)
- * @param _to - End of time range (unused - can be ignored in live implementations)
- * @param _backtest - Whether running in backtest mode (unused)
- */
-const DEFAULT_GET_ORDER_BOOK_FN$1 = async (_symbol, _depth, _from, _to, _backtest) => {
-    throw new Error(`getOrderBook is not implemented for this exchange`);
-};
 /**
- * Connection service routing exchange operations to correct ClientExchange instance.
- *
- * Routes all IExchange method calls to the appropriate exchange implementation
- * based on methodContextService.context.exchangeName. Uses memoization to cache
- * ClientExchange instances for performance.
+ * Utility class for managing signal persistence.
  *
- * Key features:
- * - Automatic exchange routing via method context
- * - Memoized ClientExchange instances by exchangeName
- * - Implements full IExchange interface
- * - Logging for all operations
+ * Features:
+ * - Memoized storage instances per strategy
+ * - Custom adapter support
+ * - Atomic read/write operations
+ * - Crash-safe signal state management
  *
- * @example
- * ```typescript
- * // Used internally by framework
- * const candles = await exchangeConnectionService.getCandles(
- *   "BTCUSDT", "1h", 100
- * );
- * // Automatically routes to correct exchange based on methodContext
- * ```
+ * Used by ClientStrategy for live mode persistence.
  */
-class ExchangeConnectionService {
+class PersistSignalUtils {
     constructor() {
-        this.loggerService = inject(TYPES.loggerService);
-        this.executionContextService = inject(TYPES.executionContextService);
-        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
-        this.methodContextService = inject(TYPES.methodContextService);
-        /**
-         * Retrieves memoized ClientExchange instance for given exchange name.
-         *
-         * Creates ClientExchange on first call, returns cached instance on subsequent calls.
-         * Cache key is exchangeName string.
-         *
-         * @param exchangeName - Name of registered exchange schema
-         * @returns Configured ClientExchange instance
-         */
-        this.getExchange = functoolsKit.memoize(([exchangeName]) => `${exchangeName}`, (exchangeName) => {
-            const { getCandles = DEFAULT_GET_CANDLES_FN$1, formatPrice = DEFAULT_FORMAT_PRICE_FN$1, formatQuantity = DEFAULT_FORMAT_QUANTITY_FN$1, getOrderBook = DEFAULT_GET_ORDER_BOOK_FN$1, callbacks } = this.exchangeSchemaService.get(exchangeName);
-            return new ClientExchange({
-                execution: this.executionContextService,
-                logger: this.loggerService,
-                exchangeName,
-                getCandles,
-                formatPrice,
-                formatQuantity,
-                getOrderBook,
-                callbacks,
-            });
-        });
-        /**
-         * Fetches historical candles for symbol using configured exchange.
-         *
-         * Routes to exchange determined by methodContextService.context.exchangeName.
-         *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param interval - Candle interval (e.g., "1h", "1d")
-         * @param limit - Maximum number of candles to fetch
-         * @returns Promise resolving to array of candle data
-         */
-        this.getCandles = async (symbol, interval, limit) => {
-            this.loggerService.log("exchangeConnectionService getCandles", {
-                symbol,
-                interval,
-                limit,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).getCandles(symbol, interval, limit);
-        };
+        this.PersistSignalFactory = PersistBase;
+        this.getSignalStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistSignalFactory, [
+            `${symbol}_${strategyName}_${exchangeName}`,
+            `./dump/data/signal/`,
+        ]));
         /**
-         * Fetches next batch of candles relative to executionContext.when.
+         * Reads persisted signal data for a symbol and strategy.
          *
-         * Returns candles that come after the current execution timestamp.
-         * Used for backtest progression and live trading updates.
+         * Called by ClientStrategy.waitForInit() to restore state.
+         * Returns null if no signal exists.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param interval - Candle interval (e.g., "1h", "1d")
-         * @param limit - Maximum number of candles to fetch
-         * @returns Promise resolving to array of candle data
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise resolving to signal or null
          */
-        this.getNextCandles = async (symbol, interval, limit) => {
-            this.loggerService.log("exchangeConnectionService getNextCandles", {
-                symbol,
-                interval,
-                limit,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).getNextCandles(symbol, interval, limit);
+        this.readSignalData = async (symbol, strategyName, exchangeName) => {
+            bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
+            const key = `${symbol}:${strategyName}:${exchangeName}`;
+            const isInitial = !this.getSignalStorage.has(key);
+            const stateStorage = this.getSignalStorage(symbol, strategyName, exchangeName);
+            await stateStorage.waitForInit(isInitial);
+            if (await stateStorage.hasValue(symbol)) {
+                return await stateStorage.readValue(symbol);
+            }
+            return null;
         };
         /**
-         * Retrieves current average price for symbol.
+         * Writes signal data to disk with atomic file writes.
          *
-         * In live mode: fetches real-time average price from exchange API.
-         * In backtest mode: calculates VWAP from candles in current timeframe.
+         * Called by ClientStrategy.setPendingSignal() to persist state.
+         * Uses atomic writes to prevent corruption on crashes.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @returns Promise resolving to average price
+         * @param signalRow - Signal data (null to clear)
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise that resolves when write is complete
          */
-        this.getAveragePrice = async (symbol) => {
-            this.loggerService.log("exchangeConnectionService getAveragePrice", {
-                symbol,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).getAveragePrice(symbol);
-        };
-        /**
-         * Formats price according to exchange-specific precision rules.
-         *
-         * Ensures price meets exchange requirements for decimal places and tick size.
-         *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param price - Raw price value to format
-         * @returns Promise resolving to formatted price string
-         */
-        this.formatPrice = async (symbol, price) => {
-            this.loggerService.log("exchangeConnectionService getAveragePrice", {
-                symbol,
-                price,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).formatPrice(symbol, price);
+        this.writeSignalData = async (signalRow, symbol, strategyName, exchangeName) => {
+            bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
+            const key = `${symbol}:${strategyName}:${exchangeName}`;
+            const isInitial = !this.getSignalStorage.has(key);
+            const stateStorage = this.getSignalStorage(symbol, strategyName, exchangeName);
+            await stateStorage.waitForInit(isInitial);
+            await stateStorage.writeValue(symbol, signalRow);
         };
+    }
+    /**
+     * Registers a custom persistence 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);
+     * ```
+     */
+    usePersistSignalAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
+        this.PersistSignalFactory = Ctor;
+    }
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistSignalAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistSignalAdapter(PersistDummy);
+    }
+}
+/**
+ * Global singleton instance of PersistSignalUtils.
+ * Used by ClientStrategy for signal persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistSignalAdapter.usePersistSignalAdapter(RedisPersist);
+ *
+ * // Read signal
+ * const signal = await PersistSignalAdapter.readSignalData("my-strategy", "BTCUSDT");
+ *
+ * // Write signal
+ * await PersistSignalAdapter.writeSignalData(signal, "my-strategy", "BTCUSDT");
+ * ```
+ */
+const PersistSignalAdapter = new PersistSignalUtils();
+/**
+ * Utility class for managing risk active positions persistence.
+ *
+ * Features:
+ * - Memoized storage instances per risk profile
+ * - Custom adapter support
+ * - Atomic read/write operations for RiskData
+ * - Crash-safe position state management
+ *
+ * Used by ClientRisk for live mode persistence of active positions.
+ */
+class PersistRiskUtils {
+    constructor() {
+        this.PersistRiskFactory = PersistBase;
+        this.getRiskStorage = functoolsKit.memoize(([riskName, exchangeName]) => `${riskName}:${exchangeName}`, (riskName, exchangeName) => Reflect.construct(this.PersistRiskFactory, [
+            `${riskName}_${exchangeName}`,
+            `./dump/data/risk/`,
+        ]));
         /**
-         * Formats quantity according to exchange-specific precision rules.
+         * Reads persisted active positions for a risk profile.
          *
-         * Ensures quantity meets exchange requirements for decimal places and lot size.
+         * Called by ClientRisk.waitForInit() to restore state.
+         * Returns empty Map if no positions exist.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param quantity - Raw quantity value to format
-         * @returns Promise resolving to formatted quantity string
+         * @param riskName - Risk profile identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise resolving to Map of active positions
          */
-        this.formatQuantity = async (symbol, quantity) => {
-            this.loggerService.log("exchangeConnectionService getAveragePrice", {
-                symbol,
-                quantity,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).formatQuantity(symbol, quantity);
+        this.readPositionData = async (riskName, exchangeName) => {
+            bt.loggerService.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 [];
         };
         /**
-         * Fetches order book for a trading pair using configured exchange.
+         * Writes active positions to disk with atomic file writes.
          *
-         * Routes to exchange determined by methodContextService.context.exchangeName.
-         * The ClientExchange will calculate time range and pass it to the schema
-         * implementation, which may use (backtest) or ignore (live) the parameters.
+         * Called by ClientRisk after addSignal/removeSignal to persist state.
+         * Uses atomic writes to prevent corruption on crashes.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
-         * @returns Promise resolving to order book data
+         * @param positions - Map of active positions
+         * @param riskName - Risk profile identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise that resolves when write is complete
          */
-        this.getOrderBook = async (symbol, depth) => {
-            this.loggerService.log("exchangeConnectionService getOrderBook", {
-                symbol,
-                depth,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).getOrderBook(symbol, depth);
+        this.writePositionData = async (riskRow, riskName, exchangeName) => {
+            bt.loggerService.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);
         };
     }
+    /**
+     * Registers a custom persistence 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);
+     * ```
+     */
+    usePersistRiskAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
+        this.PersistRiskFactory = Ctor;
+    }
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistRiskAdapter(PersistBase);
+    }
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistRiskAdapter(PersistDummy);
+    }
 }
-
 /**
- * Calculates profit/loss for a closed signal with slippage and fees.
- *
- * For signals with partial closes:
- * - Calculates weighted PNL: Σ(percent_i × pnl_i) for each partial + (remaining% × final_pnl)
- * - Each partial close has its own fees and slippage
- * - Total fees = 2 × (number of partial closes + 1 final close) × CC_PERCENT_FEE
- *
- * Formula breakdown:
- * 1. Apply slippage to open/close prices (worse execution)
- *    - LONG: buy higher (+slippage), sell lower (-slippage)
- *    - SHORT: sell lower (-slippage), buy higher (+slippage)
- * 2. Calculate raw PNL percentage
- *    - LONG: ((closePrice - openPrice) / openPrice) * 100
- *    - SHORT: ((openPrice - closePrice) / openPrice) * 100
- * 3. Subtract total fees (0.1% * 2 = 0.2% per transaction)
- *
- * @param signal - Closed signal with position details and optional partial history
- * @param priceClose - Actual close price at final exit
- * @returns PNL data with percentage and prices
+ * Global singleton instance of PersistRiskUtils.
+ * Used by ClientRisk for active positions persistence.
  *
  * @example
  * ```typescript
- * // Signal without partial closes
- * const pnl = toProfitLossDto(
- *   {
- *     position: "long",
- *     priceOpen: 100,
- *   },
- *   110 // close at +10%
- * );
- * console.log(pnl.pnlPercentage); // ~9.6% (after slippage and fees)
+ * // Custom adapter
+ * PersistRiskAdapter.usePersistRiskAdapter(RedisPersist);
  *
- * // Signal with partial closes
- * const pnlPartial = toProfitLossDto(
- *   {
- *     position: "long",
- *     priceOpen: 100,
- *     _partial: [
- *       { type: "profit", percent: 30, price: 120 }, // +20% on 30%
- *       { type: "profit", percent: 40, price: 115 }, // +15% on 40%
- *     ],
- *   },
- *   105 // final close at +5% for remaining 30%
- * );
- * // Weighted PNL = 30% × 20% + 40% × 15% + 30% × 5% = 6% + 6% + 1.5% = 13.5% (before fees)
+ * // Read positions
+ * const positions = await PersistRiskAdapter.readPositionData("my-risk");
+ *
+ * // Write positions
+ * await PersistRiskAdapter.writePositionData(positionsMap, "my-risk");
  * ```
  */
-const toProfitLossDto = (signal, priceClose) => {
-    const priceOpen = signal.priceOpen;
-    // Calculate weighted PNL with partial closes
-    if (signal._partial && signal._partial.length > 0) {
-        let totalWeightedPnl = 0;
-        let totalFees = 0;
-        // Calculate PNL for each partial close
-        for (const partial of signal._partial) {
-            const partialPercent = partial.percent;
-            const partialPrice = partial.price;
-            // Apply slippage to prices
-            let priceOpenWithSlippage;
-            let priceCloseWithSlippage;
-            if (signal.position === "long") {
-                priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-                priceCloseWithSlippage = partialPrice * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-            }
-            else {
-                priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-                priceCloseWithSlippage = partialPrice * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-            }
-            // Calculate PNL for this partial
-            let partialPnl;
-            if (signal.position === "long") {
-                partialPnl = ((priceCloseWithSlippage - priceOpenWithSlippage) / priceOpenWithSlippage) * 100;
-            }
-            else {
-                partialPnl = ((priceOpenWithSlippage - priceCloseWithSlippage) / priceOpenWithSlippage) * 100;
-            }
-            // Weight by percentage of position closed
-            const weightedPnl = (partialPercent / 100) * partialPnl;
-            totalWeightedPnl += weightedPnl;
-            // Each partial has fees for open + close (2 transactions)
-            totalFees += GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
-        }
-        // Calculate PNL for remaining position (if any)
-        // Compute totalClosed from _partial array
-        const totalClosed = signal._partial.reduce((sum, p) => sum + p.percent, 0);
-        const remainingPercent = 100 - totalClosed;
-        if (remainingPercent > 0) {
-            // Apply slippage
-            let priceOpenWithSlippage;
-            let priceCloseWithSlippage;
-            if (signal.position === "long") {
-                priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-                priceCloseWithSlippage = priceClose * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-            }
-            else {
-                priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-                priceCloseWithSlippage = priceClose * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-            }
-            // Calculate PNL for remaining
-            let remainingPnl;
-            if (signal.position === "long") {
-                remainingPnl = ((priceCloseWithSlippage - priceOpenWithSlippage) / priceOpenWithSlippage) * 100;
-            }
-            else {
-                remainingPnl = ((priceOpenWithSlippage - priceCloseWithSlippage) / priceOpenWithSlippage) * 100;
+const PersistRiskAdapter = new PersistRiskUtils();
+/**
+ * Utility class for managing scheduled signal persistence.
+ *
+ * Features:
+ * - Memoized storage instances per strategy
+ * - Custom adapter support
+ * - Atomic read/write operations for scheduled signals
+ * - Crash-safe scheduled signal state management
+ *
+ * Used by ClientStrategy for live mode persistence of scheduled signals (_scheduledSignal).
+ */
+class PersistScheduleUtils {
+    constructor() {
+        this.PersistScheduleFactory = PersistBase;
+        this.getScheduleStorage = functoolsKit.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.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise resolving to scheduled signal or null
+         */
+        this.readScheduleData = async (symbol, strategyName, exchangeName) => {
+            bt.loggerService.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);
             }
-            // Weight by remaining percentage
-            const weightedRemainingPnl = (remainingPercent / 100) * remainingPnl;
-            totalWeightedPnl += weightedRemainingPnl;
-            // Final close also has fees
-            totalFees += GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
-        }
-        // Subtract total fees from weighted PNL
-        const pnlPercentage = totalWeightedPnl - totalFees;
-        return {
-            pnlPercentage,
-            priceOpen,
-            priceClose,
+            return null;
+        };
+        /**
+         * 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.
+         *
+         * @param scheduledSignalRow - Scheduled signal data (null to clear)
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise that resolves when write is complete
+         */
+        this.writeScheduleData = async (scheduledSignalRow, symbol, strategyName, exchangeName) => {
+            bt.loggerService.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);
         };
     }
-    // Original logic for signals without partial closes
-    let priceOpenWithSlippage;
-    let priceCloseWithSlippage;
-    if (signal.position === "long") {
-        // LONG: покупаем дороже, продаем дешевле
-        priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-        priceCloseWithSlippage = priceClose * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-    }
-    else {
-        // SHORT: продаем дешевле, покупаем дороже
-        priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
-        priceCloseWithSlippage = priceClose * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+    /**
+     * Registers a custom persistence 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)); }
+     * }
+     * PersistScheduleAdapter.usePersistScheduleAdapter(RedisPersist);
+     * ```
+     */
+    usePersistScheduleAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
+        this.PersistScheduleFactory = Ctor;
     }
-    // Применяем комиссию дважды (при открытии и закрытии)
-    const totalFee = GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
-    let pnlPercentage;
-    if (signal.position === "long") {
-        // LONG: прибыль при росте цены
-        pnlPercentage =
-            ((priceCloseWithSlippage - priceOpenWithSlippage) /
-                priceOpenWithSlippage) *
-                100;
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistScheduleAdapter(PersistBase);
     }
-    else {
-        // SHORT: прибыль при падении цены
-        pnlPercentage =
-            ((priceOpenWithSlippage - priceCloseWithSlippage) /
-                priceOpenWithSlippage) *
-                100;
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistScheduleAdapter(PersistDummy);
     }
-    // Вычитаем комиссии
-    pnlPercentage -= totalFee;
-    return {
-        pnlPercentage,
-        priceOpen,
-        priceClose,
-    };
-};
-
-const IS_WINDOWS = os.platform() === "win32";
+}
 /**
- * Atomically writes data to a file, ensuring the operation either fully completes or leaves the original file unchanged.
- * Uses a temporary file with a rename strategy on POSIX systems for atomicity, or direct writing with sync on Windows (or when POSIX rename is skipped).
- *
- *
- * @param {string} file - The file parameter.
- * @param {string | Buffer} data - The data to be processed or validated.
- * @param {Options | BufferEncoding} options - The options parameter (optional).
- * @throws {Error} Throws an error if the write, sync, or rename operation fails, after attempting cleanup of temporary files.
+ * Global singleton instance of PersistScheduleUtils.
+ * Used by ClientStrategy for scheduled signal persistence.
  *
  * @example
- * // Basic usage with default options
- * await writeFileAtomic("output.txt", "Hello, world!");
- * // Writes "Hello, world!" to "output.txt" atomically
+ * ```typescript
+ * // Custom adapter
+ * PersistScheduleAdapter.usePersistScheduleAdapter(RedisPersist);
  *
- * @example
- * // Custom options and Buffer data
- * const buffer = Buffer.from("Binary data");
- * await writeFileAtomic("data.bin", buffer, { encoding: "binary", mode: 0o644, tmpPrefix: "temp-" });
- * // Writes binary data to "data.bin" with custom permissions and temp prefix
+ * // Read scheduled signal
+ * const scheduled = await PersistScheduleAdapter.readScheduleData("my-strategy", "BTCUSDT");
  *
- * @example
- * // Using encoding shorthand
- * await writeFileAtomic("log.txt", "Log entry", "utf16le");
- * // Writes "Log entry" to "log.txt" in UTF-16LE encoding
+ * // Write scheduled signal
+ * await PersistScheduleAdapter.writeScheduleData(scheduled, "my-strategy", "BTCUSDT");
+ * ```
+ */
+const PersistScheduleAdapter = new PersistScheduleUtils();
+/**
+ * Utility class for managing partial profit/loss levels persistence.
  *
- * @remarks
- * This function ensures atomicity to prevent partial writes:
- * - On POSIX systems (non-Windows, unless `GLOBAL_CONFIG.CC_SKIP_POSIX_RENAME` is true):
- *   - Writes data to a temporary file (e.g., `.tmp-<random>-filename`) in the same directory.
- *   - Uses `crypto.randomBytes` to generate a unique temporary name, reducing collision risk.
- *   - Syncs the data to disk and renames the temporary file to the target file atomically with `fs.rename`.
- *   - Cleans up the temporary file on failure, swallowing cleanup errors to prioritize throwing the original error.
- * - On Windows (or when POSIX rename is skipped):
- *   - Writes directly to the target file, syncing data to disk to minimize corruption risk (though not fully atomic).
- *   - Closes the file handle on failure without additional cleanup.
- * - Accepts `options` as an object or a string (interpreted as `encoding`), defaulting to `{ encoding: "utf8", mode: 0o666, tmpPrefix: ".tmp-" }`.
- * Useful in the agent swarm system for safely writing configuration files, logs, or state data where partial writes could cause corruption.
+ * Features:
+ * - Memoized storage instances per symbol:strategyName
+ * - Custom adapter support
+ * - Atomic read/write operations for partial data
+ * - Crash-safe partial state management
  *
- * @see {@link https://nodejs.org/api/fs.html#fspromiseswritefilefile-data-options|fs.promises.writeFile} for file writing details.
- * @see {@link https://nodejs.org/api/crypto.html#cryptorandombytessize-callback|crypto.randomBytes} for temporary file naming.
- * @see {@link ../config/params|GLOBAL_CONFIG} for configuration impacting POSIX behavior.
-*/
-async function writeFileAtomic(file, data, options = {}) {
-    if (typeof options === "string") {
-        options = { encoding: options };
-    }
-    else if (!options) {
-        options = {};
-    }
-    const { encoding = "utf8", mode = 0o666, tmpPrefix = ".tmp-" } = options;
-    let fileHandle = null;
-    if (IS_WINDOWS) {
-        try {
-            // Create and write to temporary file
-            fileHandle = await fs.open(file, "w", mode);
-            // Write data to the temp file
-            await fileHandle.writeFile(data, { encoding });
-            // Ensure data is flushed to disk
-            await fileHandle.sync();
-            // Close the file before rename
-            await fileHandle.close();
-        }
-        catch (error) {
-            // Clean up if something went wrong
-            if (fileHandle) {
-                await fileHandle.close().catch(() => { });
-            }
-            throw error; // Re-throw the original error
-        }
-        return;
-    }
-    // Create a temporary filename in the same directory
-    const dir = path.dirname(file);
-    const filename = path.basename(file);
-    const tmpFile = path.join(dir, `${tmpPrefix}${crypto.randomBytes(6).toString("hex")}-${filename}`);
-    try {
-        // Create and write to temporary file
-        fileHandle = await fs.open(tmpFile, "w", mode);
-        // Write data to the temp file
-        await fileHandle.writeFile(data, { encoding });
-        // Ensure data is flushed to disk
-        await fileHandle.sync();
-        // Close the file before rename
-        await fileHandle.close();
-        fileHandle = null;
-        // Atomically replace the target file with our temp file
-        await fs.rename(tmpFile, file);
-    }
-    catch (error) {
-        // Clean up if something went wrong
-        if (fileHandle) {
-            await fileHandle.close().catch(() => { });
-        }
-        // Try to remove the temporary file
-        try {
-            await fs.unlink(tmpFile).catch(() => { });
-        }
-        catch (_) {
-            // Ignore errors during cleanup
-        }
-        throw error;
-    }
-}
-
-var _a$2;
-const BASE_WAIT_FOR_INIT_SYMBOL = Symbol("wait-for-init");
-const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER = "PersistSignalUtils.usePersistSignalAdapter";
-const PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA = "PersistSignalUtils.readSignalData";
-const PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistSignalUtils.writeSignalData";
-const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON = "PersistSignalUtils.useJson";
-const PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY = "PersistSignalUtils.useDummy";
-const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER = "PersistScheduleUtils.usePersistScheduleAdapter";
-const PERSIST_SCHEDULE_UTILS_METHOD_NAME_READ_DATA = "PersistScheduleUtils.readScheduleData";
-const PERSIST_SCHEDULE_UTILS_METHOD_NAME_WRITE_DATA = "PersistScheduleUtils.writeScheduleData";
-const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON = "PersistScheduleUtils.useJson";
-const PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY = "PersistScheduleUtils.useDummy";
-const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER = "PersistPartialUtils.usePersistPartialAdapter";
-const PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA = "PersistPartialUtils.readPartialData";
-const PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA = "PersistPartialUtils.writePartialData";
-const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON = "PersistPartialUtils.useJson";
-const PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY = "PersistPartialUtils.useDummy";
-const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER = "PersistBreakevenUtils.usePersistBreakevenAdapter";
-const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA = "PersistBreakevenUtils.readBreakevenData";
-const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA = "PersistBreakevenUtils.writeBreakevenData";
-const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON = "PersistBreakevenUtils.useJson";
-const PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY = "PersistBreakevenUtils.useDummy";
-const PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER = "PersistRiskUtils.usePersistRiskAdapter";
-const PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA = "PersistRiskUtils.readPositionData";
-const PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA = "PersistRiskUtils.writePositionData";
-const PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON = "PersistRiskUtils.useJson";
-const PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY = "PersistRiskUtils.useDummy";
-const PERSIST_BASE_METHOD_NAME_CTOR = "PersistBase.CTOR";
-const PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT = "PersistBase.waitForInit";
-const PERSIST_BASE_METHOD_NAME_READ_VALUE = "PersistBase.readValue";
-const PERSIST_BASE_METHOD_NAME_WRITE_VALUE = "PersistBase.writeValue";
-const PERSIST_BASE_METHOD_NAME_HAS_VALUE = "PersistBase.hasValue";
-const PERSIST_BASE_METHOD_NAME_KEYS = "PersistBase.keys";
-const BASE_WAIT_FOR_INIT_FN_METHOD_NAME = "PersistBase.waitForInitFn";
-const BASE_UNLINK_RETRY_COUNT = 5;
-const BASE_UNLINK_RETRY_DELAY = 1000;
-const BASE_WAIT_FOR_INIT_FN = async (self) => {
-    bt.loggerService.debug(BASE_WAIT_FOR_INIT_FN_METHOD_NAME, {
-        entityName: self.entityName,
-        directory: self._directory,
-    });
-    await fs.mkdir(self._directory, { recursive: true });
-    for await (const key of self.keys()) {
-        try {
-            await self.readValue(key);
-        }
-        catch {
-            const filePath = self._getFilePath(key);
-            console.error(`backtest-kit PersistBase found invalid document for filePath=${filePath} entityName=${self.entityName}`);
-            if (await functoolsKit.not(BASE_WAIT_FOR_INIT_UNLINK_FN(filePath))) {
-                console.error(`backtest-kit PersistBase failed to remove invalid document for filePath=${filePath} entityName=${self.entityName}`);
+ * Used by ClientPartial for live mode persistence of profit/loss levels.
+ */
+class PersistPartialUtils {
+    constructor() {
+        this.PersistPartialFactory = PersistBase;
+        this.getPartialStorage = functoolsKit.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.
+         *
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param signalId - Signal identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise resolving to partial data record
+         */
+        this.readPartialData = async (symbol, strategyName, signalId, exchangeName) => {
+            bt.loggerService.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 {};
+        };
+        /**
+         * Writes partial data to disk with atomic file writes.
+         *
+         * 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 symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param signalId - Signal identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise that resolves when write is complete
+         */
+        this.writePartialData = async (partialData, symbol, strategyName, signalId, exchangeName) => {
+            bt.loggerService.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 BASE_WAIT_FOR_INIT_UNLINK_FN = async (filePath) => functoolsKit.trycatch(functoolsKit.retry(async () => {
-    try {
-        await fs.unlink(filePath);
-        return true;
+    /**
+     * Registers a custom persistence 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);
+     * ```
+     */
+    usePersistPartialAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
+        this.PersistPartialFactory = Ctor;
     }
-    catch (error) {
-        console.error(`backtest-kit PersistBase unlink failed for filePath=${filePath} error=${functoolsKit.getErrorMessage(error)}`);
-        throw error;
+    /**
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
+     */
+    useJson() {
+        bt.loggerService.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistPartialAdapter(PersistBase);
     }
-}, BASE_UNLINK_RETRY_COUNT, BASE_UNLINK_RETRY_DELAY), {
-    defaultValue: false,
-});
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
+     */
+    useDummy() {
+        bt.loggerService.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistPartialAdapter(PersistDummy);
+    }
+}
 /**
- * Base class for file-based persistence with atomic writes.
+ * Global singleton instance of PersistPartialUtils.
+ * Used by ClientPartial for partial profit/loss levels persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistPartialAdapter.usePersistPartialAdapter(RedisPersist);
+ *
+ * // Read partial data
+ * const partialData = await PersistPartialAdapter.readPartialData("BTCUSDT", "my-strategy");
+ *
+ * // Write partial data
+ * await PersistPartialAdapter.writePartialData(partialData, "BTCUSDT", "my-strategy");
+ * ```
+ */
+const PersistPartialAdapter = new PersistPartialUtils();
+/**
+ * Persistence utility class for breakeven state management.
+ *
+ * Handles reading and writing breakeven state to disk.
+ * Uses memoized PersistBase instances per symbol-strategy pair.
  *
  * Features:
- * - Atomic file writes using writeFileAtomic
- * - Auto-validation and cleanup of corrupted files
- * - Async generator support for iteration
- * - Retry logic for file deletion
+ * - Atomic file writes via PersistBase.writeValue()
+ * - Lazy initialization on first access
+ * - Singleton pattern for global access
+ * - Custom adapter support via usePersistBreakevenAdapter()
+ *
+ * File structure:
+ * ```
+ * ./dump/data/breakeven/
+ * ├── BTCUSDT_my-strategy/
+ * │   └── state.json        // { "signal-id-1": { reached: true }, ... }
+ * └── ETHUSDT_other-strategy/
+ *     └── state.json
+ * ```
  *
  * @example
  * ```typescript
- * const persist = new PersistBase("my-entity", "./data");
- * await persist.waitForInit(true);
- * await persist.writeValue("key1", { data: "value" });
- * const value = await persist.readValue("key1");
+ * // Read breakeven data
+ * const breakevenData = await PersistBreakevenAdapter.readBreakevenData("BTCUSDT", "my-strategy");
+ * // Returns: { "signal-id": { reached: true }, ... }
+ *
+ * // Write breakeven data
+ * await PersistBreakevenAdapter.writeBreakevenData(breakevenData, "BTCUSDT", "my-strategy");
  * ```
  */
-class PersistBase {
-    /**
-     * Creates new persistence instance.
-     *
-     * @param entityName - Unique entity type identifier
-     * @param baseDir - Base directory for all entities (default: ./dump/data)
-     */
-    constructor(entityName, baseDir = path.join(process.cwd(), "logs/data")) {
-        this.entityName = entityName;
-        this.baseDir = baseDir;
-        this[_a$2] = functoolsKit.singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
-            entityName: this.entityName,
-            baseDir,
-        });
-        this._directory = path.join(this.baseDir, this.entityName);
-    }
-    /**
-     * Computes file path for entity ID.
-     *
-     * @param entityId - Entity identifier
-     * @returns Full file path to entity JSON file
-     */
-    _getFilePath(entityId) {
-        return path.join(this.baseDir, this.entityName, `${entityId}.json`);
-    }
-    async waitForInit(initial) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WAIT_FOR_INIT, {
-            entityName: this.entityName,
-            initial,
-        });
-        await this[BASE_WAIT_FOR_INIT_SYMBOL]();
-    }
-    async readValue(entityId) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_READ_VALUE, {
-            entityName: this.entityName,
-            entityId,
-        });
-        try {
-            const filePath = this._getFilePath(entityId);
-            const fileContent = await fs.readFile(filePath, "utf-8");
-            return JSON.parse(fileContent);
-        }
-        catch (error) {
-            if (error?.code === "ENOENT") {
-                throw new Error(`Entity ${this.entityName}:${entityId} not found`);
-            }
-            throw new Error(`Failed to read entity ${this.entityName}:${entityId}: ${functoolsKit.getErrorMessage(error)}`);
-        }
-    }
-    async hasValue(entityId) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_HAS_VALUE, {
-            entityName: this.entityName,
-            entityId,
-        });
-        try {
-            const filePath = this._getFilePath(entityId);
-            await fs.access(filePath);
-            return true;
-        }
-        catch (error) {
-            if (error?.code === "ENOENT") {
-                return false;
-            }
-            throw new Error(`Failed to check existence of entity ${this.entityName}:${entityId}: ${functoolsKit.getErrorMessage(error)}`);
-        }
-    }
-    async writeValue(entityId, entity) {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_WRITE_VALUE, {
-            entityName: this.entityName,
-            entityId,
-        });
-        try {
-            const filePath = this._getFilePath(entityId);
-            const serializedData = JSON.stringify(entity);
-            await writeFileAtomic(filePath, serializedData, "utf-8");
-        }
-        catch (error) {
-            throw new Error(`Failed to write entity ${this.entityName}:${entityId}: ${functoolsKit.getErrorMessage(error)}`);
-        }
-    }
-    /**
-     * Async generator yielding all entity IDs.
-     * Sorted alphanumerically.
-     * Used internally by waitForInit for validation.
-     *
-     * @returns AsyncGenerator yielding entity IDs
-     * @throws Error if reading fails
-     */
-    async *keys() {
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
-            entityName: this.entityName,
-        });
-        try {
-            const files = await fs.readdir(this._directory);
-            const entityIds = files
-                .filter((file) => file.endsWith(".json"))
-                .map((file) => file.slice(0, -5))
-                .sort((a, b) => a.localeCompare(b, undefined, {
-                numeric: true,
-                sensitivity: "base",
-            }));
-            for (const entityId of entityIds) {
-                yield entityId;
-            }
-        }
-        catch (error) {
-            throw new Error(`Failed to read keys for ${this.entityName}: ${functoolsKit.getErrorMessage(error)}`);
-        }
-    }
-}
-_a$2 = BASE_WAIT_FOR_INIT_SYMBOL;
-// @ts-ignore
-PersistBase = functoolsKit.makeExtendable(PersistBase);
-/**
- * Dummy persist adapter that discards all writes.
- * Used for disabling persistence.
- */
-class PersistDummy {
-    /**
-     * No-op initialization function.
-     * @returns Promise that resolves immediately
-     */
-    async waitForInit() {
-    }
-    /**
-     * No-op read function.
-     * @returns Promise that resolves with empty object
-     */
-    async readValue() {
-        return {};
-    }
-    /**
-     * No-op has value check.
-     * @returns Promise that resolves to false
-     */
-    async hasValue() {
-        return false;
-    }
-    /**
-     * No-op write function.
-     * @returns Promise that resolves immediately
-     */
-    async writeValue() {
-    }
-}
-/**
- * Utility class for managing signal persistence.
- *
- * Features:
- * - Memoized storage instances per strategy
- * - Custom adapter support
- * - Atomic read/write operations
- * - Crash-safe signal state management
- *
- * Used by ClientStrategy for live mode persistence.
- */
-class PersistSignalUtils {
+class PersistBreakevenUtils {
     constructor() {
-        this.PersistSignalFactory = PersistBase;
-        this.getSignalStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistSignalFactory, [
+        /**
+         * Factory for creating PersistBase instances.
+         * Can be replaced via usePersistBreakevenAdapter().
+         */
+        this.PersistBreakevenFactory = PersistBase;
+        /**
+         * 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
+         */
+        this.getBreakevenStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistBreakevenFactory, [
             `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/signal/`,
+            `./dump/data/breakeven/`,
         ]));
         /**
-         * Reads persisted signal data for a symbol and strategy.
+         * Reads persisted breakeven data for a symbol and strategy.
          *
-         * Called by ClientStrategy.waitForInit() to restore state.
-         * Returns null if no signal exists.
+         * Called by ClientBreakeven.waitForInit() to restore state.
+         * Returns empty object if no breakeven data exists.
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
+         * @param signalId - Signal identifier
          * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to signal or null
+         * @returns Promise resolving to breakeven data record
          */
-        this.readSignalData = async (symbol, strategyName, exchangeName) => {
-            bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_READ_DATA);
+        this.readBreakevenData = async (symbol, strategyName, signalId, exchangeName) => {
+            bt.loggerService.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_READ_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
-            const isInitial = !this.getSignalStorage.has(key);
-            const stateStorage = this.getSignalStorage(symbol, strategyName, exchangeName);
+            const isInitial = !this.getBreakevenStorage.has(key);
+            const stateStorage = this.getBreakevenStorage(symbol, strategyName, exchangeName);
             await stateStorage.waitForInit(isInitial);
-            if (await stateStorage.hasValue(symbol)) {
-                return await stateStorage.readValue(symbol);
+            if (await stateStorage.hasValue(signalId)) {
+                return await stateStorage.readValue(signalId);
             }
-            return null;
+            return {};
         };
         /**
-         * Writes signal data to disk with atomic file writes.
+         * Writes breakeven data to disk.
          *
-         * Called by ClientStrategy.setPendingSignal() to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Called by ClientBreakeven._persistState() after state changes.
+         * Creates directory and file if they don't exist.
+         * Uses atomic writes to prevent data corruption.
          *
-         * @param signalRow - Signal data (null to clear)
+         * @param breakevenData - Breakeven data record to persist
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy identifier
+         * @param signalId - Signal identifier
          * @param exchangeName - Exchange identifier
          * @returns Promise that resolves when write is complete
          */
-        this.writeSignalData = async (signalRow, symbol, strategyName, exchangeName) => {
-            bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_WRITE_DATA);
+        this.writeBreakevenData = async (breakevenData, symbol, strategyName, signalId, exchangeName) => {
+            bt.loggerService.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_WRITE_DATA);
             const key = `${symbol}:${strategyName}:${exchangeName}`;
-            const isInitial = !this.getSignalStorage.has(key);
-            const stateStorage = this.getSignalStorage(symbol, strategyName, exchangeName);
+            const isInitial = !this.getBreakevenStorage.has(key);
+            const stateStorage = this.getBreakevenStorage(symbol, strategyName, exchangeName);
             await stateStorage.waitForInit(isInitial);
-            await stateStorage.writeValue(symbol, signalRow);
+            await stateStorage.writeValue(signalId, breakevenData);
         };
     }
     /**
@@ -1712,538 +1492,1109 @@ class PersistSignalUtils {
      *   async readValue(id) { return JSON.parse(await redis.get(id)); }
      *   async writeValue(id, entity) { await redis.set(id, JSON.stringify(entity)); }
      * }
-     * PersistSignalAdapter.usePersistSignalAdapter(RedisPersist);
+     * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
      * ```
      */
-    usePersistSignalAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_PERSIST_SIGNAL_ADAPTER);
-        this.PersistSignalFactory = Ctor;
+    usePersistBreakevenAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
+        this.PersistBreakevenFactory = Ctor;
     }
     /**
      * Switches to the default JSON persist adapter.
      * All future persistence writes will use JSON storage.
      */
     useJson() {
-        bt.loggerService.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistSignalAdapter(PersistBase);
+        bt.loggerService.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistBreakevenAdapter(PersistBase);
     }
     /**
      * Switches to a dummy persist adapter that discards all writes.
      * All future persistence writes will be no-ops.
      */
     useDummy() {
-        bt.loggerService.log(PERSIST_SIGNAL_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistSignalAdapter(PersistDummy);
+        bt.loggerService.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistBreakevenAdapter(PersistDummy);
     }
 }
 /**
- * Global singleton instance of PersistSignalUtils.
- * Used by ClientStrategy for signal persistence.
+ * Global singleton instance of PersistBreakevenUtils.
+ * Used by ClientBreakeven for breakeven state persistence.
  *
  * @example
  * ```typescript
  * // Custom adapter
- * PersistSignalAdapter.usePersistSignalAdapter(RedisPersist);
+ * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
  *
- * // Read signal
- * const signal = await PersistSignalAdapter.readSignalData("my-strategy", "BTCUSDT");
+ * // Read breakeven data
+ * const breakevenData = await PersistBreakevenAdapter.readBreakevenData("BTCUSDT", "my-strategy");
  *
- * // Write signal
- * await PersistSignalAdapter.writeSignalData(signal, "my-strategy", "BTCUSDT");
+ * // Write breakeven data
+ * await PersistBreakevenAdapter.writeBreakevenData(breakevenData, "BTCUSDT", "my-strategy");
  * ```
  */
-const PersistSignalAdapter = new PersistSignalUtils();
+const PersistBreakevenAdapter = new PersistBreakevenUtils();
 /**
- * Utility class for managing risk active positions persistence.
+ * Utility class for managing candles cache persistence.
  *
  * Features:
- * - Memoized storage instances per risk profile
- * - Custom adapter support
- * - Atomic read/write operations for RiskData
- * - Crash-safe position state management
+ * - Each candle stored as separate JSON file: ${exchangeName}/${symbol}/${interval}/${timestamp}.json
+ * - Cache validation: returns cached data if file count matches requested limit
+ * - Automatic cache invalidation and refresh when data is incomplete
+ * - Atomic read/write operations
  *
- * Used by ClientRisk for live mode persistence of active positions.
+ * Used by ClientExchange for candle data caching.
  */
-class PersistRiskUtils {
+class PersistCandleUtils {
     constructor() {
-        this.PersistRiskFactory = PersistBase;
-        this.getRiskStorage = functoolsKit.memoize(([riskName, exchangeName]) => `${riskName}:${exchangeName}`, (riskName, exchangeName) => Reflect.construct(this.PersistRiskFactory, [
-            `${riskName}_${exchangeName}`,
-            `./dump/data/risk/`,
+        this.PersistCandlesFactory = PersistBase;
+        this.getCandlesStorage = functoolsKit.memoize(([symbol, interval, exchangeName]) => `${symbol}:${interval}:${exchangeName}`, (symbol, interval, exchangeName) => Reflect.construct(this.PersistCandlesFactory, [
+            `${exchangeName}/${symbol}/${interval}`,
+            `./dump/data/candles/`,
         ]));
         /**
-         * Reads persisted active positions for a risk profile.
-         *
-         * Called by ClientRisk.waitForInit() to restore state.
-         * Returns empty Map if no positions exist.
+         * Reads cached candles for a specific exchange, symbol, and interval.
+         * Returns candles only if cache contains exactly the requested limit.
          *
-         * @param riskName - Risk profile identifier
+         * @param symbol - Trading pair symbol
+         * @param interval - Candle interval
          * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to Map of active positions
+         * @param limit - Number of candles requested
+         * @param sinceTimestamp - Start timestamp (inclusive)
+         * @param untilTimestamp - End timestamp (exclusive)
+         * @returns Promise resolving to array of candles or null if cache is incomplete
          */
-        this.readPositionData = async (riskName, exchangeName) => {
-            bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_READ_DATA);
-            const key = `${riskName}:${exchangeName}`;
-            const isInitial = !this.getRiskStorage.has(key);
-            const stateStorage = this.getRiskStorage(riskName, exchangeName);
+        this.readCandlesData = async (symbol, interval, exchangeName, limit, sinceTimestamp, untilTimestamp) => {
+            bt.loggerService.info("PersistCandleUtils.readCandlesData", {
+                symbol,
+                interval,
+                exchangeName,
+                limit,
+                sinceTimestamp,
+                untilTimestamp,
+            });
+            const key = `${symbol}:${interval}:${exchangeName}`;
+            const isInitial = !this.getCandlesStorage.has(key);
+            const stateStorage = this.getCandlesStorage(symbol, interval, 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 [];
+            // Collect all cached candles within the time range
+            const cachedCandles = [];
+            for await (const timestamp of stateStorage.keys()) {
+                const ts = Number(timestamp);
+                if (ts >= sinceTimestamp && ts < untilTimestamp) {
+                    try {
+                        const candle = await stateStorage.readValue(timestamp);
+                        cachedCandles.push(candle);
+                    }
+                    catch {
+                        // Skip invalid candles
+                        continue;
+                    }
+                }
+            }
+            // Sort by timestamp ascending
+            cachedCandles.sort((a, b) => a.timestamp - b.timestamp);
+            return cachedCandles;
         };
         /**
-         * Writes active positions to disk with atomic file writes.
-         *
-         * Called by ClientRisk after addSignal/removeSignal to persist state.
-         * Uses atomic writes to prevent corruption on crashes.
+         * Writes candles to cache with atomic file writes.
+         * Each candle is stored as a separate JSON file named by its timestamp.
          *
-         * @param positions - Map of active positions
-         * @param riskName - Risk profile identifier
+         * @param candles - Array of candle data to cache
+         * @param symbol - Trading pair symbol
+         * @param interval - Candle interval
          * @param exchangeName - Exchange identifier
-         * @returns Promise that resolves when write is complete
+         * @returns Promise that resolves when all writes are complete
          */
-        this.writePositionData = async (riskRow, riskName, exchangeName) => {
-            bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_WRITE_DATA);
-            const key = `${riskName}:${exchangeName}`;
-            const isInitial = !this.getRiskStorage.has(key);
-            const stateStorage = this.getRiskStorage(riskName, exchangeName);
+        this.writeCandlesData = async (candles, symbol, interval, exchangeName) => {
+            bt.loggerService.info("PersistCandleUtils.writeCandlesData", {
+                symbol,
+                interval,
+                exchangeName,
+                candleCount: candles.length,
+            });
+            const key = `${symbol}:${interval}:${exchangeName}`;
+            const isInitial = !this.getCandlesStorage.has(key);
+            const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
             await stateStorage.waitForInit(isInitial);
-            const RISK_STORAGE_KEY = "positions";
-            await stateStorage.writeValue(RISK_STORAGE_KEY, riskRow);
+            // Write each candle as a separate file
+            for (const candle of candles) {
+                if (await functoolsKit.not(stateStorage.hasValue(String(candle.timestamp)))) {
+                    await stateStorage.writeValue(String(candle.timestamp), candle);
+                }
+            }
         };
     }
     /**
      * Registers a custom persistence 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);
-     * ```
      */
-    usePersistRiskAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
-        this.PersistRiskFactory = Ctor;
+    usePersistCandleAdapter(Ctor) {
+        bt.loggerService.info("PersistCandleUtils.usePersistCandleAdapter");
+        this.PersistCandlesFactory = Ctor;
     }
     /**
      * Switches to the default JSON persist adapter.
      * All future persistence writes will use JSON storage.
      */
     useJson() {
-        bt.loggerService.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistRiskAdapter(PersistBase);
+        bt.loggerService.log("PersistCandleUtils.useJson");
+        this.usePersistCandleAdapter(PersistBase);
     }
     /**
      * Switches to a dummy persist adapter that discards all writes.
      * All future persistence writes will be no-ops.
      */
     useDummy() {
-        bt.loggerService.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistRiskAdapter(PersistDummy);
+        bt.loggerService.log("PersistCandleUtils.useDummy");
+        this.usePersistCandleAdapter(PersistDummy);
     }
 }
 /**
- * Global singleton instance of PersistRiskUtils.
- * Used by ClientRisk for active positions persistence.
+ * Global singleton instance of PersistCandleUtils.
+ * Used by ClientExchange for candle data caching.
  *
  * @example
  * ```typescript
- * // Custom adapter
- * PersistRiskAdapter.usePersistRiskAdapter(RedisPersist);
- *
- * // Read positions
- * const positions = await PersistRiskAdapter.readPositionData("my-risk");
+ * // Read cached candles
+ * const candles = await PersistCandleAdapter.readCandlesData(
+ *   "BTCUSDT", "1m", "binance", 100, since.getTime(), until.getTime()
+ * );
  *
- * // Write positions
- * await PersistRiskAdapter.writePositionData(positionsMap, "my-risk");
+ * // Write candles to cache
+ * await PersistCandleAdapter.writeCandlesData(candles, "BTCUSDT", "1m", "binance");
  * ```
  */
-const PersistRiskAdapter = new PersistRiskUtils();
+const PersistCandleAdapter = new PersistCandleUtils();
+
+const INTERVAL_MINUTES$4 = {
+    "1m": 1,
+    "3m": 3,
+    "5m": 5,
+    "15m": 15,
+    "30m": 30,
+    "1h": 60,
+    "2h": 120,
+    "4h": 240,
+    "6h": 360,
+    "8h": 480,
+};
 /**
- * Utility class for managing scheduled signal persistence.
- *
- * Features:
- * - Memoized storage instances per strategy
- * - Custom adapter support
- * - Atomic read/write operations for scheduled signals
- * - Crash-safe scheduled signal state management
+ * Validates that all candles have valid OHLCV data without anomalies.
+ * Detects incomplete candles from Binance API by checking for abnormally low prices or volumes.
+ * Incomplete candles often have prices like 0.1 instead of normal 100,000 or zero volume.
  *
- * Used by ClientStrategy for live mode persistence of scheduled signals (_scheduledSignal).
+ * @param candles - Array of candle data to validate
+ * @throws Error if any candles have anomalous OHLCV values
  */
-class PersistScheduleUtils {
-    constructor() {
-        this.PersistScheduleFactory = PersistBase;
-        this.getScheduleStorage = functoolsKit.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.
-         *
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to scheduled signal or null
-         */
-        this.readScheduleData = async (symbol, strategyName, exchangeName) => {
-            bt.loggerService.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;
-        };
-        /**
-         * 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.
-         *
-         * @param scheduledSignalRow - Scheduled signal data (null to clear)
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise that resolves when write is complete
-         */
-        this.writeScheduleData = async (scheduledSignalRow, symbol, strategyName, exchangeName) => {
-            bt.loggerService.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 VALIDATE_NO_INCOMPLETE_CANDLES_FN = (candles) => {
+    if (candles.length === 0) {
+        return;
     }
-    /**
-     * Registers a custom persistence 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)); }
-     * }
-     * PersistScheduleAdapter.usePersistScheduleAdapter(RedisPersist);
-     * ```
-     */
-    usePersistScheduleAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_PERSIST_SCHEDULE_ADAPTER);
-        this.PersistScheduleFactory = Ctor;
+    // Calculate reference price (median or average depending on candle count)
+    const allPrices = candles.flatMap((c) => [c.open, c.high, c.low, c.close]);
+    const validPrices = allPrices.filter((p) => p > 0);
+    let referencePrice;
+    if (candles.length >= GLOBAL_CONFIG.CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN) {
+        // Use median for reliable statistics with enough data
+        const sortedPrices = [...validPrices].sort((a, b) => a - b);
+        referencePrice = sortedPrices[Math.floor(sortedPrices.length / 2)] || 0;
     }
-    /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
-     */
-    useJson() {
-        bt.loggerService.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistScheduleAdapter(PersistBase);
+    else {
+        // Use average for small datasets (more stable than median)
+        const sum = validPrices.reduce((acc, p) => acc + p, 0);
+        referencePrice = validPrices.length > 0 ? sum / validPrices.length : 0;
     }
-    /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
-     */
-    useDummy() {
-        bt.loggerService.log(PERSIST_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistScheduleAdapter(PersistDummy);
+    if (referencePrice === 0) {
+        throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: cannot calculate reference price (all prices are zero)`);
     }
-}
+    const minValidPrice = referencePrice /
+        GLOBAL_CONFIG.CC_GET_CANDLES_PRICE_ANOMALY_THRESHOLD_FACTOR;
+    for (let i = 0; i < candles.length; i++) {
+        const candle = candles[i];
+        // Check for invalid numeric values
+        if (!Number.isFinite(candle.open) ||
+            !Number.isFinite(candle.high) ||
+            !Number.isFinite(candle.low) ||
+            !Number.isFinite(candle.close) ||
+            !Number.isFinite(candle.volume) ||
+            !Number.isFinite(candle.timestamp)) {
+            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has invalid numeric values (NaN or Infinity)`);
+        }
+        // Check for negative values
+        if (candle.open <= 0 ||
+            candle.high <= 0 ||
+            candle.low <= 0 ||
+            candle.close <= 0 ||
+            candle.volume < 0) {
+            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has zero or negative values`);
+        }
+        // Check for anomalously low prices (incomplete candle indicator)
+        if (candle.open < minValidPrice ||
+            candle.high < minValidPrice ||
+            candle.low < minValidPrice ||
+            candle.close < minValidPrice) {
+            throw new Error(`VALIDATE_NO_INCOMPLETE_CANDLES_FN: candle[${i}] has anomalously low price. ` +
+                `OHLC: [${candle.open}, ${candle.high}, ${candle.low}, ${candle.close}], ` +
+                `reference: ${referencePrice}, threshold: ${minValidPrice}`);
+        }
+    }
+};
 /**
- * Global singleton instance of PersistScheduleUtils.
- * Used by ClientStrategy for scheduled signal persistence.
- *
- * @example
- * ```typescript
- * // Custom adapter
- * PersistScheduleAdapter.usePersistScheduleAdapter(RedisPersist);
- *
- * // Read scheduled signal
- * const scheduled = await PersistScheduleAdapter.readScheduleData("my-strategy", "BTCUSDT");
+ * Attempts to read candles from cache.
+ * Validates cache consistency (no gaps in timestamps) before returning.
  *
- * // Write scheduled signal
- * await PersistScheduleAdapter.writeScheduleData(scheduled, "my-strategy", "BTCUSDT");
- * ```
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param sinceTimestamp - Start timestamp in milliseconds
+ * @param untilTimestamp - End timestamp in milliseconds
+ * @param self - Instance of ClientExchange
+ * @returns Cached candles array or null if cache miss or inconsistent
  */
-const PersistScheduleAdapter = new PersistScheduleUtils();
+const READ_CANDLES_CACHE_FN$1 = functoolsKit.trycatch(async (dto, sinceTimestamp, untilTimestamp, self) => {
+    const cachedCandles = await PersistCandleAdapter.readCandlesData(dto.symbol, dto.interval, self.params.exchangeName, dto.limit, sinceTimestamp, untilTimestamp);
+    // Return cached data only if we have exactly the requested limit
+    if (cachedCandles.length === dto.limit) {
+        self.params.logger.debug(`ClientExchange READ_CANDLES_CACHE_FN: cache hit for symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
+        return cachedCandles;
+    }
+    self.params.logger.warn(`ClientExchange READ_CANDLES_CACHE_FN: cache inconsistent (count or range mismatch) for symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
+    return null;
+}, {
+    fallback: async (error) => {
+        const message = `ClientExchange READ_CANDLES_CACHE_FN: cache read failed`;
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
- * Utility class for managing partial profit/loss levels persistence.
- *
- * Features:
- * - Memoized storage instances per symbol:strategyName
- * - Custom adapter support
- * - Atomic read/write operations for partial data
- * - Crash-safe partial state management
+ * Writes candles to cache with error handling.
  *
- * Used by ClientPartial for live mode persistence of profit/loss levels.
+ * @param candles - Array of candle data to cache
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param self - Instance of ClientExchange
  */
-class PersistPartialUtils {
-    constructor() {
-        this.PersistPartialFactory = PersistBase;
-        this.getPartialStorage = functoolsKit.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.
-         *
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param signalId - Signal identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to partial data record
-         */
-        this.readPartialData = async (symbol, strategyName, signalId, exchangeName) => {
-            bt.loggerService.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 WRITE_CANDLES_CACHE_FN$1 = functoolsKit.trycatch(functoolsKit.queued(async (candles, dto, self) => {
+    await PersistCandleAdapter.writeCandlesData(candles, dto.symbol, dto.interval, self.params.exchangeName);
+    self.params.logger.debug(`ClientExchange WRITE_CANDLES_CACHE_FN: cache updated for symbol=${dto.symbol}, interval=${dto.interval}, count=${candles.length}`);
+}), {
+    fallback: async (error) => {
+        const message = `ClientExchange WRITE_CANDLES_CACHE_FN: cache write failed`;
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
         };
-        /**
-         * Writes partial data to disk with atomic file writes.
-         *
-         * 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 symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param signalId - Signal identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise that resolves when write is complete
-         */
-        this.writePartialData = async (partialData, symbol, strategyName, signalId, exchangeName) => {
-            bt.loggerService.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);
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+/**
+ * Retries the getCandles function with specified retry count and delay.
+ * Uses cache to avoid redundant API calls.
+ *
+ * Cache logic:
+ * - Checks if cached candles exist for the time range
+ * - If cache has exactly dto.limit candles, returns cached data
+ * - Otherwise, fetches from API and updates cache
+ *
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param since - Date object representing the start time for fetching candles
+ * @param self - Instance of ClientExchange
+ * @returns Promise resolving to array of candle data
+ */
+const GET_CANDLES_FN = async (dto, since, self) => {
+    const step = INTERVAL_MINUTES$4[dto.interval];
+    const sinceTimestamp = since.getTime();
+    const untilTimestamp = sinceTimestamp + dto.limit * step * 60 * 1000;
+    // Try to read from cache first
+    const cachedCandles = await READ_CANDLES_CACHE_FN$1(dto, sinceTimestamp, untilTimestamp, self);
+    if (cachedCandles !== null) {
+        return cachedCandles;
+    }
+    // Cache miss or error - fetch from API
+    let lastError;
+    for (let i = 0; i !== GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_COUNT; i++) {
+        try {
+            const result = await self.params.getCandles(dto.symbol, dto.interval, since, dto.limit, self.params.execution.context.backtest);
+            VALIDATE_NO_INCOMPLETE_CANDLES_FN(result);
+            // Write to cache after successful fetch
+            await WRITE_CANDLES_CACHE_FN$1(result, dto, self);
+            return result;
+        }
+        catch (err) {
+            const message = `ClientExchange GET_CANDLES_FN: attempt ${i + 1} failed for symbol=${dto.symbol}, interval=${dto.interval}, since=${since.toISOString()}, limit=${dto.limit}}`;
+            const payload = {
+                error: functoolsKit.errorData(err),
+                message: functoolsKit.getErrorMessage(err),
+            };
+            self.params.logger.warn(message, payload);
+            console.warn(message, payload);
+            lastError = err;
+            await functoolsKit.sleep(GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS);
+        }
+    }
+    throw lastError;
+};
+/**
+ * Wrapper to call onCandleData callback with error handling.
+ * Catches and logs any errors thrown by the user-provided callback.
+ *
+ * @param self - ClientExchange instance reference
+ * @param symbol - Trading pair symbol
+ * @param interval - Candle interval
+ * @param since - Start date for candle data
+ * @param limit - Number of candles
+ * @param data - Array of candle data
+ */
+const CALL_CANDLE_DATA_CALLBACKS_FN = functoolsKit.trycatch(async (self, symbol, interval, since, limit, data) => {
+    if (self.params.callbacks?.onCandleData) {
+        await self.params.callbacks.onCandleData(symbol, interval, since, limit, data);
+    }
+}, {
+    fallback: (error) => {
+        const message = "ClientExchange CALL_CANDLE_DATA_CALLBACKS_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
         };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Client implementation for exchange data access.
+ *
+ * Features:
+ * - Historical candle fetching (backwards from execution context)
+ * - Future candle fetching (forwards for backtest)
+ * - VWAP calculation from last 5 1m candles
+ * - Price/quantity formatting for exchange
+ *
+ * All methods use prototype functions for memory efficiency.
+ *
+ * @example
+ * ```typescript
+ * const exchange = new ClientExchange({
+ *   exchangeName: "binance",
+ *   getCandles: async (symbol, interval, since, limit) => [...],
+ *   formatPrice: async (symbol, price) => price.toFixed(2),
+ *   formatQuantity: async (symbol, quantity) => quantity.toFixed(8),
+ *   execution: executionService,
+ *   logger: loggerService,
+ * });
+ *
+ * const candles = await exchange.getCandles("BTCUSDT", "1m", 100);
+ * const vwap = await exchange.getAveragePrice("BTCUSDT");
+ * ```
+ */
+class ClientExchange {
+    constructor(params) {
+        this.params = params;
+    }
+    /**
+     * Fetches historical candles backwards from execution context time.
+     *
+     * @param symbol - Trading pair symbol
+     * @param interval - Candle interval
+     * @param limit - Number of candles to fetch
+     * @returns Promise resolving to array of candles
+     */
+    async getCandles(symbol, interval, limit) {
+        this.params.logger.debug(`ClientExchange getCandles`, {
+            symbol,
+            interval,
+            limit,
+        });
+        const step = INTERVAL_MINUTES$4[interval];
+        const adjust = step * limit;
+        if (!adjust) {
+            throw new Error(`ClientExchange unknown time adjust for interval=${interval}`);
+        }
+        const since = new Date(this.params.execution.context.when.getTime() - adjust * 60 * 1000);
+        let allData = [];
+        // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
+        if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
+            let remaining = limit;
+            let currentSince = new Date(since.getTime());
+            while (remaining > 0) {
+                const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
+                const chunkData = await GET_CANDLES_FN({ symbol, interval, limit: chunkLimit }, currentSince, this);
+                allData.push(...chunkData);
+                remaining -= chunkLimit;
+                if (remaining > 0) {
+                    // Move currentSince forward by the number of candles fetched
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * 60 * 1000);
+                }
+            }
+        }
+        else {
+            allData = await GET_CANDLES_FN({ symbol, interval, limit }, since, this);
+        }
+        // Filter candles to strictly match the requested range
+        const whenTimestamp = this.params.execution.context.when.getTime();
+        const sinceTimestamp = since.getTime();
+        const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp &&
+            candle.timestamp < whenTimestamp);
+        // Apply distinct by timestamp to remove duplicates
+        const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
+        if (filteredData.length !== uniqueData.length) {
+            const msg = `ClientExchange Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`;
+            this.params.logger.warn(msg);
+            console.warn(msg);
+        }
+        if (uniqueData.length < limit) {
+            const msg = `ClientExchange Expected ${limit} candles, got ${uniqueData.length}`;
+            this.params.logger.warn(msg);
+            console.warn(msg);
+        }
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, uniqueData);
+        return uniqueData;
+    }
+    /**
+     * Fetches future candles forwards from execution context time.
+     * Used in backtest mode to get candles for signal duration.
+     *
+     * @param symbol - Trading pair symbol
+     * @param interval - Candle interval
+     * @param limit - Number of candles to fetch
+     * @returns Promise resolving to array of candles
+     * @throws Error if trying to fetch future candles in live mode
+     */
+    async getNextCandles(symbol, interval, limit) {
+        this.params.logger.debug(`ClientExchange getNextCandles`, {
+            symbol,
+            interval,
+            limit,
+        });
+        const since = new Date(this.params.execution.context.when.getTime());
+        const now = Date.now();
+        // Вычисляем конечное время запроса
+        const step = INTERVAL_MINUTES$4[interval];
+        const endTime = since.getTime() + limit * step * 60 * 1000;
+        // Проверяем что запрошенный период не заходит за Date.now()
+        if (endTime > now) {
+            return [];
+        }
+        let allData = [];
+        // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
+        if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
+            let remaining = limit;
+            let currentSince = new Date(since.getTime());
+            while (remaining > 0) {
+                const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
+                const chunkData = await GET_CANDLES_FN({ symbol, interval, limit: chunkLimit }, currentSince, this);
+                allData.push(...chunkData);
+                remaining -= chunkLimit;
+                if (remaining > 0) {
+                    // Move currentSince forward by the number of candles fetched
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * 60 * 1000);
+                }
+            }
+        }
+        else {
+            allData = await GET_CANDLES_FN({ symbol, interval, limit }, since, this);
+        }
+        // Filter candles to strictly match the requested range
+        const sinceTimestamp = since.getTime();
+        const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp < endTime);
+        // Apply distinct by timestamp to remove duplicates
+        const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
+        if (filteredData.length !== uniqueData.length) {
+            const msg = `ClientExchange getNextCandles: Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`;
+            this.params.logger.warn(msg);
+            console.warn(msg);
+        }
+        if (uniqueData.length < limit) {
+            const msg = `ClientExchange getNextCandles: Expected ${limit} candles, got ${uniqueData.length}`;
+            this.params.logger.warn(msg);
+            console.warn(msg);
+        }
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, uniqueData);
+        return uniqueData;
+    }
+    /**
+     * Calculates VWAP (Volume Weighted Average Price) from last N 1m candles.
+     * The number of candles is configurable via GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT.
+     *
+     * Formula:
+     * - Typical Price = (high + low + close) / 3
+     * - VWAP = sum(typical_price * volume) / sum(volume)
+     *
+     * If volume is zero, returns simple average of close prices.
+     *
+     * @param symbol - Trading pair symbol
+     * @returns Promise resolving to VWAP price
+     * @throws Error if no candles available
+     */
+    async getAveragePrice(symbol) {
+        this.params.logger.debug(`ClientExchange getAveragePrice`, {
+            symbol,
+        });
+        const candles = await this.getCandles(symbol, "1m", GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT);
+        if (candles.length === 0) {
+            throw new Error(`ClientExchange getAveragePrice: no candles data for symbol=${symbol}`);
+        }
+        // VWAP (Volume Weighted Average Price)
+        // Используем типичную цену (typical price) = (high + low + close) / 3
+        const sumPriceVolume = candles.reduce((acc, candle) => {
+            const typicalPrice = (candle.high + candle.low + candle.close) / 3;
+            return acc + typicalPrice * candle.volume;
+        }, 0);
+        const totalVolume = candles.reduce((acc, candle) => acc + candle.volume, 0);
+        if (totalVolume === 0) {
+            // Если объем нулевой, возвращаем простое среднее close цен
+            const sum = candles.reduce((acc, candle) => acc + candle.close, 0);
+            return sum / candles.length;
+        }
+        const vwap = sumPriceVolume / totalVolume;
+        return vwap;
     }
     /**
-     * Registers a custom persistence adapter.
+     * Formats quantity according to exchange-specific rules for the given symbol.
+     * Applies proper decimal precision and rounding based on symbol's lot size filters.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * @param symbol - Trading pair symbol
+     * @param quantity - Raw quantity to format
+     * @returns Promise resolving to formatted quantity as string
+     */
+    async formatQuantity(symbol, quantity) {
+        this.params.logger.debug("binanceService formatQuantity", {
+            symbol,
+            quantity,
+        });
+        return await this.params.formatQuantity(symbol, quantity, this.params.execution.context.backtest);
+    }
+    /**
+     * Formats price according to exchange-specific rules for the given symbol.
+     * Applies proper decimal precision and rounding based on symbol's price filters.
      *
-     * @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 symbol - Trading pair symbol
+     * @param price - Raw price to format
+     * @returns Promise resolving to formatted price as string
      */
-    usePersistPartialAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
-        this.PersistPartialFactory = Ctor;
+    async formatPrice(symbol, price) {
+        this.params.logger.debug("binanceService formatPrice", {
+            symbol,
+            price,
+        });
+        return await this.params.formatPrice(symbol, price, this.params.execution.context.backtest);
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * Fetches raw candles with flexible date/limit parameters.
+     *
+     * Compatibility layer that:
+     * - RAW MODE (sDate + eDate + limit): fetches exactly as specified, NO look-ahead bias protection
+     * - Other modes: respects execution context and prevents look-ahead bias
+     *
+     * Parameter combinations:
+     * 1. sDate + eDate + limit: RAW MODE - fetches exactly as specified, no validation against when
+     * 2. sDate + eDate: calculates limit from date range, validates endTimestamp <= when
+     * 3. eDate + limit: calculates sDate backward, validates endTimestamp <= when
+     * 4. sDate + limit: fetches forward, validates endTimestamp <= when
+     * 5. Only limit: uses execution.context.when as reference (backward)
+     *
+     * Edge cases:
+     * - If calculated limit is 0 or negative: throws error
+     * - If sDate >= eDate: throws error
+     * - If startTimestamp >= endTimestamp: throws error
+     * - If endTimestamp > when (non-RAW modes only): throws error to prevent look-ahead bias
+     *
+     * @param symbol - Trading pair symbol
+     * @param interval - Candle interval
+     * @param limit - Optional number of candles to fetch
+     * @param sDate - Optional start date in milliseconds
+     * @param eDate - Optional end date in milliseconds
+     * @returns Promise resolving to array of candles
+     * @throws Error if parameters are invalid or conflicting
      */
-    useJson() {
-        bt.loggerService.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistPartialAdapter(PersistBase);
+    async getRawCandles(symbol, interval, limit, sDate, eDate) {
+        this.params.logger.debug(`ClientExchange getRawCandles`, {
+            symbol,
+            interval,
+            limit,
+            sDate,
+            eDate,
+        });
+        const step = INTERVAL_MINUTES$4[interval];
+        const stepMs = step * 60 * 1000;
+        const when = this.params.execution.context.when.getTime();
+        let startTimestamp;
+        let endTimestamp;
+        let candleLimit;
+        let isRawMode = false;
+        // Case 1: sDate + eDate + limit - RAW MODE (no look-ahead bias protection)
+        if (sDate !== undefined &&
+            eDate !== undefined &&
+            limit !== undefined) {
+            isRawMode = true;
+            if (sDate >= eDate) {
+                throw new Error(`ClientExchange getRawCandles: sDate (${sDate}) must be less than eDate (${eDate})`);
+            }
+            startTimestamp = sDate;
+            endTimestamp = eDate;
+            candleLimit = limit;
+        }
+        // Case 2: sDate + eDate - calculate limit, respect backtest context
+        else if (sDate !== undefined && eDate !== undefined && limit === undefined) {
+            if (sDate >= eDate) {
+                throw new Error(`ClientExchange getRawCandles: sDate (${sDate}) must be less than eDate (${eDate})`);
+            }
+            startTimestamp = sDate;
+            endTimestamp = eDate;
+            const rangeDuration = endTimestamp - startTimestamp;
+            candleLimit = Math.floor(rangeDuration / stepMs);
+            if (candleLimit <= 0) {
+                throw new Error(`ClientExchange getRawCandles: calculated limit is ${candleLimit} for range [${sDate}, ${eDate}]`);
+            }
+        }
+        // Case 3: eDate + limit - calculate sDate backward, respect backtest context
+        else if (eDate !== undefined && limit !== undefined && sDate === undefined) {
+            endTimestamp = eDate;
+            startTimestamp = eDate - limit * stepMs;
+            candleLimit = limit;
+        }
+        // Case 4: sDate + limit - fetch forward, respect backtest context
+        else if (sDate !== undefined && limit !== undefined && eDate === undefined) {
+            startTimestamp = sDate;
+            endTimestamp = sDate + limit * stepMs;
+            candleLimit = limit;
+        }
+        // Case 5: Only limit - use execution context (backward from when)
+        else if (limit !== undefined && sDate === undefined && eDate === undefined) {
+            endTimestamp = when;
+            startTimestamp = when - limit * stepMs;
+            candleLimit = limit;
+        }
+        // Invalid combination
+        else {
+            throw new Error(`ClientExchange getRawCandles: invalid parameter combination. Must provide either (limit), (eDate+limit), (sDate+limit), (sDate+eDate), or (sDate+eDate+limit)`);
+        }
+        // Validate timestamps
+        if (startTimestamp >= endTimestamp) {
+            throw new Error(`ClientExchange getRawCandles: startTimestamp (${startTimestamp}) >= endTimestamp (${endTimestamp})`);
+        }
+        // Check if trying to fetch future data (prevent look-ahead bias)
+        // ONLY for non-RAW modes - RAW MODE bypasses this check
+        if (!isRawMode && endTimestamp > when) {
+            throw new Error(`ClientExchange getRawCandles: endTimestamp (${endTimestamp}) is beyond execution context when (${when}) - look-ahead bias prevented`);
+        }
+        const since = new Date(startTimestamp);
+        let allData = [];
+        // Fetch data in chunks if limit exceeds max per request
+        if (candleLimit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
+            let remaining = candleLimit;
+            let currentSince = new Date(since.getTime());
+            while (remaining > 0) {
+                const chunkLimit = Math.min(remaining, GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST);
+                const chunkData = await GET_CANDLES_FN({ symbol, interval, limit: chunkLimit }, currentSince, this);
+                allData.push(...chunkData);
+                remaining -= chunkLimit;
+                if (remaining > 0) {
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
+                }
+            }
+        }
+        else {
+            allData = await GET_CANDLES_FN({ symbol, interval, limit: candleLimit }, since, this);
+        }
+        // Filter candles to strictly match the requested range
+        const filteredData = allData.filter((candle) => candle.timestamp >= startTimestamp &&
+            candle.timestamp < endTimestamp);
+        // Apply distinct by timestamp to remove duplicates
+        const uniqueData = Array.from(new Map(filteredData.map((candle) => [candle.timestamp, candle])).values());
+        if (filteredData.length !== uniqueData.length) {
+            const msg = `ClientExchange getRawCandles: Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`;
+            this.params.logger.warn(msg);
+            console.warn(msg);
+        }
+        if (uniqueData.length < candleLimit) {
+            const msg = `ClientExchange getRawCandles: Expected ${candleLimit} candles, got ${uniqueData.length}`;
+            this.params.logger.warn(msg);
+            console.warn(msg);
+        }
+        await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, candleLimit, uniqueData);
+        return uniqueData;
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * Fetches order book for a trading pair.
+     *
+     * Calculates time range based on execution context time (when) and
+     * CC_ORDER_BOOK_TIME_OFFSET_MINUTES, then delegates to the exchange
+     * schema implementation which may use or ignore the time range.
+     *
+     * @param symbol - Trading pair symbol
+     * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
+     * @returns Promise resolving to order book data
+     * @throws Error if getOrderBook is not implemented
      */
-    useDummy() {
-        bt.loggerService.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistPartialAdapter(PersistDummy);
+    async getOrderBook(symbol, depth = GLOBAL_CONFIG.CC_ORDER_BOOK_MAX_DEPTH_LEVELS) {
+        this.params.logger.debug("ClientExchange getOrderBook", {
+            symbol,
+            depth,
+        });
+        const to = new Date(this.params.execution.context.when.getTime());
+        const from = new Date(to.getTime() -
+            GLOBAL_CONFIG.CC_ORDER_BOOK_TIME_OFFSET_MINUTES * 60 * 1000);
+        return await this.params.getOrderBook(symbol, depth, from, to, this.params.execution.context.backtest);
     }
 }
+
 /**
- * Global singleton instance of PersistPartialUtils.
- * Used by ClientPartial for partial profit/loss levels persistence.
- *
- * @example
- * ```typescript
- * // Custom adapter
- * PersistPartialAdapter.usePersistPartialAdapter(RedisPersist);
- *
- * // Read partial data
- * const partialData = await PersistPartialAdapter.readPartialData("BTCUSDT", "my-strategy");
- *
- * // Write partial data
- * await PersistPartialAdapter.writePartialData(partialData, "BTCUSDT", "my-strategy");
- * ```
+ * Default implementation for getCandles.
+ * Throws an error indicating the method is not implemented.
  */
-const PersistPartialAdapter = new PersistPartialUtils();
+const DEFAULT_GET_CANDLES_FN$1 = async (_symbol, _interval, _since, _limit, _backtest) => {
+    throw new Error(`getCandles is not implemented for this exchange`);
+};
 /**
- * Persistence utility class for breakeven state management.
+ * Default implementation for formatQuantity.
+ * Returns Bitcoin precision on Binance (8 decimal places).
+ */
+const DEFAULT_FORMAT_QUANTITY_FN$1 = async (_symbol, quantity, _backtest) => {
+    return quantity.toFixed(8);
+};
+/**
+ * Default implementation for formatPrice.
+ * Returns Bitcoin precision on Binance (2 decimal places).
+ */
+const DEFAULT_FORMAT_PRICE_FN$1 = async (_symbol, price, _backtest) => {
+    return price.toFixed(2);
+};
+/**
+ * Default implementation for getOrderBook.
+ * Throws an error indicating the method is not implemented.
  *
- * Handles reading and writing breakeven state to disk.
- * Uses memoized PersistBase instances per symbol-strategy pair.
+ * @param _symbol - Trading pair symbol (unused)
+ * @param _depth - Maximum depth levels (unused)
+ * @param _from - Start of time range (unused - can be ignored in live implementations)
+ * @param _to - End of time range (unused - can be ignored in live implementations)
+ * @param _backtest - Whether running in backtest mode (unused)
+ */
+const DEFAULT_GET_ORDER_BOOK_FN$1 = async (_symbol, _depth, _from, _to, _backtest) => {
+    throw new Error(`getOrderBook is not implemented for this exchange`);
+};
+/**
+ * Connection service routing exchange operations to correct ClientExchange instance.
  *
- * Features:
- * - Atomic file writes via PersistBase.writeValue()
- * - Lazy initialization on first access
- * - Singleton pattern for global access
- * - Custom adapter support via usePersistBreakevenAdapter()
+ * Routes all IExchange method calls to the appropriate exchange implementation
+ * based on methodContextService.context.exchangeName. Uses memoization to cache
+ * ClientExchange instances for performance.
  *
- * File structure:
- * ```
- * ./dump/data/breakeven/
- * ├── BTCUSDT_my-strategy/
- * │   └── state.json        // { "signal-id-1": { reached: true }, ... }
- * └── ETHUSDT_other-strategy/
- *     └── state.json
- * ```
+ * Key features:
+ * - Automatic exchange routing via method context
+ * - Memoized ClientExchange instances by exchangeName
+ * - Implements full IExchange interface
+ * - Logging for all operations
  *
  * @example
  * ```typescript
- * // Read breakeven data
- * const breakevenData = await PersistBreakevenAdapter.readBreakevenData("BTCUSDT", "my-strategy");
- * // Returns: { "signal-id": { reached: true }, ... }
- *
- * // Write breakeven data
- * await PersistBreakevenAdapter.writeBreakevenData(breakevenData, "BTCUSDT", "my-strategy");
+ * // Used internally by framework
+ * const candles = await exchangeConnectionService.getCandles(
+ *   "BTCUSDT", "1h", 100
+ * );
+ * // Automatically routes to correct exchange based on methodContext
  * ```
  */
-class PersistBreakevenUtils {
+class ExchangeConnectionService {
     constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.executionContextService = inject(TYPES.executionContextService);
+        this.exchangeSchemaService = inject(TYPES.exchangeSchemaService);
+        this.methodContextService = inject(TYPES.methodContextService);
+        /**
+         * Retrieves memoized ClientExchange instance for given exchange name.
+         *
+         * Creates ClientExchange on first call, returns cached instance on subsequent calls.
+         * Cache key is exchangeName string.
+         *
+         * @param exchangeName - Name of registered exchange schema
+         * @returns Configured ClientExchange instance
+         */
+        this.getExchange = functoolsKit.memoize(([exchangeName]) => `${exchangeName}`, (exchangeName) => {
+            const { getCandles = DEFAULT_GET_CANDLES_FN$1, formatPrice = DEFAULT_FORMAT_PRICE_FN$1, formatQuantity = DEFAULT_FORMAT_QUANTITY_FN$1, getOrderBook = DEFAULT_GET_ORDER_BOOK_FN$1, callbacks } = this.exchangeSchemaService.get(exchangeName);
+            return new ClientExchange({
+                execution: this.executionContextService,
+                logger: this.loggerService,
+                exchangeName,
+                getCandles,
+                formatPrice,
+                formatQuantity,
+                getOrderBook,
+                callbacks,
+            });
+        });
+        /**
+         * Fetches historical candles for symbol using configured exchange.
+         *
+         * Routes to exchange determined by methodContextService.context.exchangeName.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle interval (e.g., "1h", "1d")
+         * @param limit - Maximum number of candles to fetch
+         * @returns Promise resolving to array of candle data
+         */
+        this.getCandles = async (symbol, interval, limit) => {
+            this.loggerService.log("exchangeConnectionService getCandles", {
+                symbol,
+                interval,
+                limit,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getCandles(symbol, interval, limit);
+        };
         /**
-         * Factory for creating PersistBase instances.
-         * Can be replaced via usePersistBreakevenAdapter().
+         * Fetches next batch of candles relative to executionContext.when.
+         *
+         * Returns candles that come after the current execution timestamp.
+         * Used for backtest progression and live trading updates.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param interval - Candle interval (e.g., "1h", "1d")
+         * @param limit - Maximum number of candles to fetch
+         * @returns Promise resolving to array of candle data
          */
-        this.PersistBreakevenFactory = PersistBase;
+        this.getNextCandles = async (symbol, interval, limit) => {
+            this.loggerService.log("exchangeConnectionService getNextCandles", {
+                symbol,
+                interval,
+                limit,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getNextCandles(symbol, interval, limit);
+        };
         /**
-         * Memoized storage factory for breakeven data.
-         * Creates one PersistBase instance per symbol-strategy-exchange combination.
-         * Key format: "symbol:strategyName:exchangeName"
+         * Retrieves current average price for symbol.
          *
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param exchangeName - Exchange identifier
-         * @returns PersistBase instance for this symbol-strategy-exchange combination
+         * In live mode: fetches real-time average price from exchange API.
+         * In backtest mode: calculates VWAP from candles in current timeframe.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @returns Promise resolving to average price
          */
-        this.getBreakevenStorage = functoolsKit.memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistBreakevenFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/breakeven/`,
-        ]));
+        this.getAveragePrice = async (symbol) => {
+            this.loggerService.log("exchangeConnectionService getAveragePrice", {
+                symbol,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getAveragePrice(symbol);
+        };
         /**
-         * Reads persisted breakeven data for a symbol and strategy.
+         * Formats price according to exchange-specific precision rules.
          *
-         * Called by ClientBreakeven.waitForInit() to restore state.
-         * Returns empty object if no breakeven data exists.
+         * Ensures price meets exchange requirements for decimal places and tick size.
          *
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param signalId - Signal identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise resolving to breakeven data record
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param price - Raw price value to format
+         * @returns Promise resolving to formatted price string
          */
-        this.readBreakevenData = async (symbol, strategyName, signalId, exchangeName) => {
-            bt.loggerService.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 {};
+        this.formatPrice = async (symbol, price) => {
+            this.loggerService.log("exchangeConnectionService getAveragePrice", {
+                symbol,
+                price,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).formatPrice(symbol, price);
         };
         /**
-         * Writes breakeven data to disk.
+         * Formats quantity according to exchange-specific precision rules.
          *
-         * Called by ClientBreakeven._persistState() after state changes.
-         * Creates directory and file if they don't exist.
-         * Uses atomic writes to prevent data corruption.
+         * Ensures quantity meets exchange requirements for decimal places and lot size.
          *
-         * @param breakevenData - Breakeven data record to persist
-         * @param symbol - Trading pair symbol
-         * @param strategyName - Strategy identifier
-         * @param signalId - Signal identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise that resolves when write is complete
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param quantity - Raw quantity value to format
+         * @returns Promise resolving to formatted quantity string
          */
-        this.writeBreakevenData = async (breakevenData, symbol, strategyName, signalId, exchangeName) => {
-            bt.loggerService.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);
+        this.formatQuantity = async (symbol, quantity) => {
+            this.loggerService.log("exchangeConnectionService getAveragePrice", {
+                symbol,
+                quantity,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).formatQuantity(symbol, quantity);
+        };
+        /**
+         * Fetches order book for a trading pair using configured exchange.
+         *
+         * Routes to exchange determined by methodContextService.context.exchangeName.
+         * The ClientExchange will calculate time range and pass it to the schema
+         * implementation, which may use (backtest) or ignore (live) the parameters.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param depth - Maximum depth levels (default: CC_ORDER_BOOK_MAX_DEPTH_LEVELS)
+         * @returns Promise resolving to order book data
+         */
+        this.getOrderBook = async (symbol, depth) => {
+            this.loggerService.log("exchangeConnectionService getOrderBook", {
+                symbol,
+                depth,
+            });
+            return await this.getExchange(this.methodContextService.context.exchangeName).getOrderBook(symbol, depth);
+        };
+    }
+}
+
+/**
+ * Calculates profit/loss for a closed signal with slippage and fees.
+ *
+ * For signals with partial closes:
+ * - Calculates weighted PNL: Σ(percent_i × pnl_i) for each partial + (remaining% × final_pnl)
+ * - Each partial close has its own fees and slippage
+ * - Total fees = 2 × (number of partial closes + 1 final close) × CC_PERCENT_FEE
+ *
+ * Formula breakdown:
+ * 1. Apply slippage to open/close prices (worse execution)
+ *    - LONG: buy higher (+slippage), sell lower (-slippage)
+ *    - SHORT: sell lower (-slippage), buy higher (+slippage)
+ * 2. Calculate raw PNL percentage
+ *    - LONG: ((closePrice - openPrice) / openPrice) * 100
+ *    - SHORT: ((openPrice - closePrice) / openPrice) * 100
+ * 3. Subtract total fees (0.1% * 2 = 0.2% per transaction)
+ *
+ * @param signal - Closed signal with position details and optional partial history
+ * @param priceClose - Actual close price at final exit
+ * @returns PNL data with percentage and prices
+ *
+ * @example
+ * ```typescript
+ * // Signal without partial closes
+ * const pnl = toProfitLossDto(
+ *   {
+ *     position: "long",
+ *     priceOpen: 100,
+ *   },
+ *   110 // close at +10%
+ * );
+ * console.log(pnl.pnlPercentage); // ~9.6% (after slippage and fees)
+ *
+ * // Signal with partial closes
+ * const pnlPartial = toProfitLossDto(
+ *   {
+ *     position: "long",
+ *     priceOpen: 100,
+ *     _partial: [
+ *       { type: "profit", percent: 30, price: 120 }, // +20% on 30%
+ *       { type: "profit", percent: 40, price: 115 }, // +15% on 40%
+ *     ],
+ *   },
+ *   105 // final close at +5% for remaining 30%
+ * );
+ * // Weighted PNL = 30% × 20% + 40% × 15% + 30% × 5% = 6% + 6% + 1.5% = 13.5% (before fees)
+ * ```
+ */
+const toProfitLossDto = (signal, priceClose) => {
+    const priceOpen = signal.priceOpen;
+    // Calculate weighted PNL with partial closes
+    if (signal._partial && signal._partial.length > 0) {
+        let totalWeightedPnl = 0;
+        let totalFees = 0;
+        // Calculate PNL for each partial close
+        for (const partial of signal._partial) {
+            const partialPercent = partial.percent;
+            const partialPrice = partial.price;
+            // Apply slippage to prices
+            let priceOpenWithSlippage;
+            let priceCloseWithSlippage;
+            if (signal.position === "long") {
+                priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+                priceCloseWithSlippage = partialPrice * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+            }
+            else {
+                priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+                priceCloseWithSlippage = partialPrice * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+            }
+            // Calculate PNL for this partial
+            let partialPnl;
+            if (signal.position === "long") {
+                partialPnl = ((priceCloseWithSlippage - priceOpenWithSlippage) / priceOpenWithSlippage) * 100;
+            }
+            else {
+                partialPnl = ((priceOpenWithSlippage - priceCloseWithSlippage) / priceOpenWithSlippage) * 100;
+            }
+            // Weight by percentage of position closed
+            const weightedPnl = (partialPercent / 100) * partialPnl;
+            totalWeightedPnl += weightedPnl;
+            // Each partial has fees for open + close (2 transactions)
+            totalFees += GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
+        }
+        // Calculate PNL for remaining position (if any)
+        // Compute totalClosed from _partial array
+        const totalClosed = signal._partial.reduce((sum, p) => sum + p.percent, 0);
+        const remainingPercent = 100 - totalClosed;
+        if (remainingPercent > 0) {
+            // Apply slippage
+            let priceOpenWithSlippage;
+            let priceCloseWithSlippage;
+            if (signal.position === "long") {
+                priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+                priceCloseWithSlippage = priceClose * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+            }
+            else {
+                priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+                priceCloseWithSlippage = priceClose * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+            }
+            // Calculate PNL for remaining
+            let remainingPnl;
+            if (signal.position === "long") {
+                remainingPnl = ((priceCloseWithSlippage - priceOpenWithSlippage) / priceOpenWithSlippage) * 100;
+            }
+            else {
+                remainingPnl = ((priceOpenWithSlippage - priceCloseWithSlippage) / priceOpenWithSlippage) * 100;
+            }
+            // Weight by remaining percentage
+            const weightedRemainingPnl = (remainingPercent / 100) * remainingPnl;
+            totalWeightedPnl += weightedRemainingPnl;
+            // Final close also has fees
+            totalFees += GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
+        }
+        // Subtract total fees from weighted PNL
+        const pnlPercentage = totalWeightedPnl - totalFees;
+        return {
+            pnlPercentage,
+            priceOpen,
+            priceClose,
         };
     }
-    /**
-     * Registers a custom persistence 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)); }
-     * }
-     * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
-     * ```
-     */
-    usePersistBreakevenAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_PERSIST_BREAKEVEN_ADAPTER);
-        this.PersistBreakevenFactory = Ctor;
+    // Original logic for signals without partial closes
+    let priceOpenWithSlippage;
+    let priceCloseWithSlippage;
+    if (signal.position === "long") {
+        // LONG: покупаем дороже, продаем дешевле
+        priceOpenWithSlippage = priceOpen * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+        priceCloseWithSlippage = priceClose * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+    }
+    else {
+        // SHORT: продаем дешевле, покупаем дороже
+        priceOpenWithSlippage = priceOpen * (1 - GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
+        priceCloseWithSlippage = priceClose * (1 + GLOBAL_CONFIG.CC_PERCENT_SLIPPAGE / 100);
     }
-    /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
-     */
-    useJson() {
-        bt.loggerService.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistBreakevenAdapter(PersistBase);
+    // Применяем комиссию дважды (при открытии и закрытии)
+    const totalFee = GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
+    let pnlPercentage;
+    if (signal.position === "long") {
+        // LONG: прибыль при росте цены
+        pnlPercentage =
+            ((priceCloseWithSlippage - priceOpenWithSlippage) /
+                priceOpenWithSlippage) *
+                100;
     }
-    /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
-     */
-    useDummy() {
-        bt.loggerService.log(PERSIST_BREAKEVEN_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistBreakevenAdapter(PersistDummy);
+    else {
+        // SHORT: прибыль при падении цены
+        pnlPercentage =
+            ((priceOpenWithSlippage - priceCloseWithSlippage) /
+                priceOpenWithSlippage) *
+                100;
     }
-}
-/**
- * Global singleton instance of PersistBreakevenUtils.
- * Used by ClientBreakeven for breakeven state persistence.
- *
- * @example
- * ```typescript
- * // Custom adapter
- * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
- *
- * // Read breakeven data
- * const breakevenData = await PersistBreakevenAdapter.readBreakevenData("BTCUSDT", "my-strategy");
- *
- * // Write breakeven data
- * await PersistBreakevenAdapter.writeBreakevenData(breakevenData, "BTCUSDT", "my-strategy");
- * ```
- */
-const PersistBreakevenAdapter = new PersistBreakevenUtils();
+    // Вычитаем комиссии
+    pnlPercentage -= totalFee;
+    return {
+        pnlPercentage,
+        priceOpen,
+        priceClose,
+    };
+};
 
 /**
  * Converts markdown content to plain text with minimal formatting
@@ -4410,6 +4761,7 @@ class ClientStrategy {
         this._lastSignalTimestamp = null;
         this._scheduledSignal = null;
         this._cancelledSignal = null;
+        this._closedSignal = null;
         /**
          * Initializes strategy state by loading persisted signal from disk.
          *
@@ -4686,6 +5038,41 @@ class ClientStrategy {
                 reason: "user",
                 cancelId: cancelledSignal.cancelId,
             };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, result, currentTime, this.params.execution.context.backtest);
+            return result;
+        }
+        // Check if pending signal was closed - emit closed event once
+        if (this._closedSignal) {
+            const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+            const closedSignal = this._closedSignal;
+            this._closedSignal = null; // Clear after emitting
+            this.params.logger.info("ClientStrategy tick: pending signal was closed", {
+                symbol: this.params.execution.context.symbol,
+                signalId: closedSignal.id,
+            });
+            // Call onClose callback
+            await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
+            // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
+            await CALL_PARTIAL_CLEAR_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
+            // КРИТИЧНО: Очищаем состояние ClientBreakeven при закрытии позиции
+            await CALL_BREAKEVEN_CLEAR_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
+            await CALL_RISK_REMOVE_SIGNAL_FN(this, this.params.execution.context.symbol, currentTime, this.params.execution.context.backtest);
+            const pnl = toProfitLossDto(closedSignal, currentPrice);
+            const result = {
+                action: "closed",
+                signal: TO_PUBLIC_SIGNAL(closedSignal),
+                currentPrice,
+                closeReason: "closed",
+                closeTimestamp: currentTime,
+                pnl,
+                strategyName: this.params.method.context.strategyName,
+                exchangeName: this.params.method.context.exchangeName,
+                frameName: this.params.method.context.frameName,
+                symbol: this.params.execution.context.symbol,
+                backtest: this.params.execution.context.backtest,
+                closeId: closedSignal.closeId,
+            };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, result, currentTime, this.params.execution.context.backtest);
             return result;
         }
         // Monitor scheduled signal
@@ -4799,8 +5186,40 @@ class ClientStrategy {
                 reason: "user",
                 cancelId: cancelledSignal.cancelId,
             };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledResult, closeTimestamp, this.params.execution.context.backtest);
             return cancelledResult;
         }
+        // If signal was closed - return closed
+        if (this._closedSignal) {
+            this.params.logger.debug("ClientStrategy backtest: pending signal was closed");
+            const currentPrice = await this.params.exchange.getAveragePrice(symbol);
+            const closedSignal = this._closedSignal;
+            this._closedSignal = null; // Clear after using
+            const closeTimestamp = this.params.execution.context.when.getTime();
+            await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
+            // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
+            await CALL_PARTIAL_CLEAR_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
+            // КРИТИЧНО: Очищаем состояние ClientBreakeven при закрытии позиции
+            await CALL_BREAKEVEN_CLEAR_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
+            await CALL_RISK_REMOVE_SIGNAL_FN(this, this.params.execution.context.symbol, closeTimestamp, this.params.execution.context.backtest);
+            const pnl = toProfitLossDto(closedSignal, currentPrice);
+            const closedResult = {
+                action: "closed",
+                signal: TO_PUBLIC_SIGNAL(closedSignal),
+                currentPrice,
+                closeReason: "closed",
+                closeTimestamp: closeTimestamp,
+                pnl,
+                strategyName: this.params.method.context.strategyName,
+                exchangeName: this.params.method.context.exchangeName,
+                frameName: this.params.method.context.frameName,
+                symbol: this.params.execution.context.symbol,
+                backtest: true,
+                closeId: closedSignal.closeId,
+            };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, closedResult, closeTimestamp, this.params.execution.context.backtest);
+            return closedResult;
+        }
         if (!this._pendingSignal && !this._scheduledSignal) {
             throw new Error("ClientStrategy backtest: no pending or scheduled signal");
         }
@@ -4927,12 +5346,12 @@ class ClientStrategy {
      * @example
      * ```typescript
      * // In Live.background() cancellation
-     * await strategy.stop();
+     * await strategy.stopStrategy();
      * // Existing signal will continue until natural close
      * ```
      */
-    async stop(symbol, backtest) {
-        this.params.logger.debug("ClientStrategy stop", {
+    async stopStrategy(symbol, backtest) {
+        this.params.logger.debug("ClientStrategy stopStrategy", {
             symbol,
             hasPendingSignal: this._pendingSignal !== null,
             hasScheduledSignal: this._scheduledSignal !== null,
@@ -4965,12 +5384,12 @@ class ClientStrategy {
      * @example
      * ```typescript
      * // Cancel scheduled signal without stopping strategy
-     * await strategy.cancel("BTCUSDT", "my-strategy", false);
+     * await strategy.cancelScheduled("BTCUSDT", "my-strategy", false);
      * // Strategy continues, can generate new signals
      * ```
      */
-    async cancel(symbol, backtest, cancelId) {
-        this.params.logger.debug("ClientStrategy cancel", {
+    async cancelScheduled(symbol, backtest, cancelId) {
+        this.params.logger.debug("ClientStrategy cancelScheduled", {
             symbol,
             hasScheduledSignal: this._scheduledSignal !== null,
             cancelId,
@@ -4987,6 +5406,45 @@ class ClientStrategy {
         }
         await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
     }
+    /**
+     * Closes the pending signal without stopping the strategy.
+     *
+     * Clears the pending signal (active position).
+     * Does NOT affect scheduled signals or strategy operation.
+     * Does NOT set stop flag - strategy can continue generating new signals.
+     *
+     * Use case: Close an active position that is no longer desired without stopping the entire strategy.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param backtest - Whether running in backtest mode
+     * @param closeId - Optional identifier for this close operation
+     * @returns Promise that resolves when pending signal is cleared
+     *
+     * @example
+     * ```typescript
+     * // Close pending signal without stopping strategy
+     * await strategy.closePending("BTCUSDT", false, "user-close-123");
+     * // Strategy continues, can generate new signals
+     * ```
+     */
+    async closePending(symbol, backtest, closeId) {
+        this.params.logger.debug("ClientStrategy closePending", {
+            symbol,
+            hasPendingSignal: this._pendingSignal !== null,
+            closeId,
+        });
+        // Save closed signal for next tick to emit closed event
+        if (this._pendingSignal) {
+            this._closedSignal = Object.assign({}, this._pendingSignal, {
+                closeId,
+            });
+            this._pendingSignal = null;
+        }
+        if (backtest) {
+            return;
+        }
+        await PersistSignalAdapter.writeSignalData(this._pendingSignal, symbol, this.params.strategyName, this.params.exchangeName);
+    }
     /**
      * Executes partial close at profit level (moving toward TP).
      *
@@ -6439,7 +6897,7 @@ class StrategyConnectionService {
         /**
          * Stops the specified strategy from generating new signals.
          *
-         * Delegates to ClientStrategy.stop() which sets internal flag to prevent
+         * Delegates to ClientStrategy.stopStrategy() which sets internal flag to prevent
          * getSignal from being called on subsequent ticks.
          *
          * @param backtest - Whether running in backtest mode
@@ -6447,13 +6905,13 @@ class StrategyConnectionService {
          * @param ctx - Context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (backtest, symbol, context) => {
-            this.loggerService.log("strategyConnectionService stop", {
+        this.stopStrategy = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyConnectionService stopStrategy", {
                 symbol,
                 context,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.stop(symbol, backtest);
+            await strategy.stopStrategy(symbol, backtest);
         };
         /**
          * Disposes the ClientStrategy instance for the given context.
@@ -6505,7 +6963,7 @@ class StrategyConnectionService {
         /**
          * Cancels the scheduled signal for the specified strategy.
          *
-         * Delegates to ClientStrategy.cancel() which clears the scheduled signal
+         * Delegates to ClientStrategy.cancelScheduled() which clears the scheduled signal
          * without stopping the strategy or affecting pending signals.
          *
          * Note: Cancelled event will be emitted on next tick() call when strategy
@@ -6517,14 +6975,39 @@ class StrategyConnectionService {
          * @param cancelId - Optional cancellation ID for user-initiated cancellations
          * @returns Promise that resolves when scheduled signal is cancelled
          */
-        this.cancel = async (backtest, symbol, context, cancelId) => {
-            this.loggerService.log("strategyConnectionService cancel", {
+        this.cancelScheduled = async (backtest, symbol, context, cancelId) => {
+            this.loggerService.log("strategyConnectionService cancelScheduled", {
                 symbol,
                 context,
                 cancelId,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
-            await strategy.cancel(symbol, backtest, cancelId);
+            await strategy.cancelScheduled(symbol, backtest, cancelId);
+        };
+        /**
+         * Closes the pending signal without stopping the strategy.
+         *
+         * Clears the pending signal (active position).
+         * Does NOT affect scheduled signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * Note: Closed event will be emitted on next tick() call when strategy
+         * detects the pending signal was closed.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @param closeId - Optional close ID for user-initiated closes
+         * @returns Promise that resolves when pending signal is closed
+         */
+        this.closePending = async (backtest, symbol, context, closeId) => {
+            this.loggerService.log("strategyConnectionService closePending", {
+                symbol,
+                context,
+                closeId,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            await strategy.closePending(symbol, backtest, closeId);
         };
         /**
          * Executes partial close at profit level (moving toward TP).
@@ -9711,19 +10194,19 @@ class StrategyCoreService {
          * @param ctx - Context with strategyName, exchangeName, frameName
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (backtest, symbol, context) => {
-            this.loggerService.log("strategyCoreService stop", {
+        this.stopStrategy = async (backtest, symbol, context) => {
+            this.loggerService.log("strategyCoreService stopStrategy", {
                 symbol,
                 context,
                 backtest,
             });
             await this.validate(context);
-            return await this.strategyConnectionService.stop(backtest, symbol, context);
+            return await this.strategyConnectionService.stopStrategy(backtest, symbol, context);
         };
         /**
          * Cancels the scheduled signal without stopping the strategy.
          *
-         * Delegates to StrategyConnectionService.cancel() to clear scheduled signal
+         * Delegates to StrategyConnectionService.cancelScheduled() to clear scheduled signal
          * and emit cancelled event through emitters.
          * Does not require execution context.
          *
@@ -9733,15 +10216,42 @@ class StrategyCoreService {
          * @param cancelId - Optional cancellation ID for user-initiated cancellations
          * @returns Promise that resolves when scheduled signal is cancelled
          */
-        this.cancel = async (backtest, symbol, context, cancelId) => {
-            this.loggerService.log("strategyCoreService cancel", {
+        this.cancelScheduled = async (backtest, symbol, context, cancelId) => {
+            this.loggerService.log("strategyCoreService cancelScheduled", {
                 symbol,
                 context,
                 backtest,
                 cancelId,
             });
             await this.validate(context);
-            return await this.strategyConnectionService.cancel(backtest, symbol, context, cancelId);
+            return await this.strategyConnectionService.cancelScheduled(backtest, symbol, context, cancelId);
+        };
+        /**
+         * Closes the pending signal without stopping the strategy.
+         *
+         * Clears the pending signal (active position).
+         * Does NOT affect scheduled signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * Delegates to StrategyConnectionService.closePending() to clear pending signal
+         * and emit closed event through emitters.
+         * Does not require execution context.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Context with strategyName, exchangeName, frameName
+         * @param closeId - Optional close ID for user-initiated closes
+         * @returns Promise that resolves when pending signal is closed
+         */
+        this.closePending = async (backtest, symbol, context, closeId) => {
+            this.loggerService.log("strategyCoreService closePending", {
+                symbol,
+                context,
+                backtest,
+                closeId,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.closePending(backtest, symbol, context, closeId);
         };
         /**
          * Disposes the ClientStrategy instance for the given context.
@@ -25027,7 +25537,8 @@ async function getOrderBook(symbol, depth) {
     return await bt.exchangeConnectionService.getOrderBook(symbol, depth);
 }
 
-const CANCEL_METHOD_NAME = "strategy.commitCancel";
+const CANCEL_SCHEDULED_METHOD_NAME = "strategy.commitCancelScheduled";
+const CLOSE_PENDING_METHOD_NAME = "strategy.commitClosePending";
 const PARTIAL_PROFIT_METHOD_NAME = "strategy.commitPartialProfit";
 const PARTIAL_LOSS_METHOD_NAME = "strategy.commitPartialLoss";
 const TRAILING_STOP_METHOD_NAME = "strategy.commitTrailingStop";
@@ -25049,26 +25560,62 @@ const BREAKEVEN_METHOD_NAME = "strategy.commitBreakeven";
  *
  * @example
  * ```typescript
- * import { cancel } from "backtest-kit";
+ * import { commitCancelScheduled } from "backtest-kit";
  *
  * // Cancel scheduled signal with custom ID
- * await cancel("BTCUSDT", "my-strategy", "manual-cancel-001");
+ * await commitCancelScheduled("BTCUSDT", "manual-cancel-001");
  * ```
  */
-async function commitCancel(symbol, cancelId) {
-    bt.loggerService.info(CANCEL_METHOD_NAME, {
+async function commitCancelScheduled(symbol, cancelId) {
+    bt.loggerService.info(CANCEL_SCHEDULED_METHOD_NAME, {
         symbol,
         cancelId,
     });
     if (!ExecutionContextService.hasContext()) {
-        throw new Error("cancel requires an execution context");
+        throw new Error("commitCancelScheduled requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitCancelScheduled requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    await bt.strategyCoreService.cancelScheduled(isBacktest, symbol, { exchangeName, frameName, strategyName }, cancelId);
+}
+/**
+ * Closes the pending signal without stopping the strategy.
+ *
+ * Clears the pending signal (active position).
+ * Does NOT affect scheduled signals or strategy operation.
+ * Does NOT set stop flag - strategy can continue generating new signals.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param closeId - Optional close ID for tracking user-initiated closes
+ * @returns Promise that resolves when pending signal is closed
+ *
+ * @example
+ * ```typescript
+ * import { commitClosePending } from "backtest-kit";
+ *
+ * // Close pending signal with custom ID
+ * await commitClosePending("BTCUSDT", "manual-close-001");
+ * ```
+ */
+async function commitClosePending(symbol, closeId) {
+    bt.loggerService.info(CLOSE_PENDING_METHOD_NAME, {
+        symbol,
+        closeId,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitClosePending requires an execution context");
     }
     if (!MethodContextService.hasContext()) {
-        throw new Error("cancel requires a method context");
+        throw new Error("commitClosePending requires a method context");
     }
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
-    await bt.strategyCoreService.cancel(isBacktest, symbol, { exchangeName, frameName, strategyName }, cancelId);
+    await bt.strategyCoreService.closePending(isBacktest, symbol, { exchangeName, frameName, strategyName }, closeId);
 }
 /**
  * Executes partial close at profit level (moving toward TP).
@@ -25315,7 +25862,7 @@ async function commitBreakeven(symbol) {
     return await bt.strategyCoreService.breakeven(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
 }
 
-const STOP_METHOD_NAME = "control.stop";
+const STOP_STRATEGY_METHOD_NAME = "control.stopStrategy";
 /**
  * Stops the strategy from generating new signals.
  *
@@ -25337,8 +25884,8 @@ const STOP_METHOD_NAME = "control.stop";
  * await stop("BTCUSDT", "my-strategy");
  * ```
  */
-async function stop(symbol) {
-    bt.loggerService.info(STOP_METHOD_NAME, {
+async function stopStrategy(symbol) {
+    bt.loggerService.info(STOP_STRATEGY_METHOD_NAME, {
         symbol,
     });
     if (!ExecutionContextService.hasContext()) {
@@ -25349,7 +25896,7 @@ async function stop(symbol) {
     }
     const { backtest: isBacktest } = bt.executionContextService.context;
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
-    await bt.strategyCoreService.stop(isBacktest, symbol, {
+    await bt.strategyCoreService.stopStrategy(isBacktest, symbol, {
         exchangeName,
         frameName,
         strategyName,
@@ -27736,7 +28283,8 @@ const BACKTEST_METHOD_NAME_GET_PENDING_SIGNAL = "BacktestUtils.getPendingSignal"
 const BACKTEST_METHOD_NAME_GET_SCHEDULED_SIGNAL = "BacktestUtils.getScheduledSignal";
 const BACKTEST_METHOD_NAME_GET_BREAKEVEN = "BacktestUtils.getBreakeven";
 const BACKTEST_METHOD_NAME_BREAKEVEN = "Backtest.commitBreakeven";
-const BACKTEST_METHOD_NAME_CANCEL = "BacktestUtils.commitCancel";
+const BACKTEST_METHOD_NAME_CANCEL_SCHEDULED = "Backtest.commitCancelScheduled";
+const BACKTEST_METHOD_NAME_CLOSE_PENDING = "Backtest.commitClosePending";
 const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.commitPartialProfit";
 const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.commitPartialLoss";
 const BACKTEST_METHOD_NAME_TRAILING_STOP = "BacktestUtils.commitTrailingStop";
@@ -27978,7 +28526,7 @@ class BacktestInstance {
             }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                bt.strategyCoreService.stop(true, symbol, {
+                bt.strategyCoreService.stopStrategy(true, symbol, {
                     strategyName: context.strategyName,
                     exchangeName: context.exchangeName,
                     frameName: context.frameName,
@@ -28246,7 +28794,7 @@ class BacktestUtils {
                 actions &&
                     actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_STOP));
             }
-            await bt.strategyCoreService.stop(true, symbol, context);
+            await bt.strategyCoreService.stopStrategy(true, symbol, context);
         };
         /**
          * Cancels the scheduled signal without stopping the strategy.
@@ -28271,24 +28819,65 @@ class BacktestUtils {
          * }, "manual-cancel-001");
          * ```
          */
-        this.commitCancel = async (symbol, context, cancelId) => {
-            bt.loggerService.info(BACKTEST_METHOD_NAME_CANCEL, {
+        this.commitCancelScheduled = async (symbol, context, cancelId) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_CANCEL_SCHEDULED, {
                 symbol,
                 context,
                 cancelId,
             });
-            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CANCEL);
-            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CANCEL);
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_CANCEL_SCHEDULED));
+            }
+            await bt.strategyCoreService.cancelScheduled(true, symbol, context, cancelId);
+        };
+        /**
+         * Closes the pending signal without stopping the strategy.
+         *
+         * Clears the pending signal (active position).
+         * Does NOT affect scheduled signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @param closeId - Optional close ID for user-initiated closes
+         * @returns Promise that resolves when pending signal is closed
+         *
+         * @example
+         * ```typescript
+         * // Close pending signal with custom ID
+         * await Backtest.commitClose("BTCUSDT", {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy",
+         *   frameName: "1m"
+         * }, "manual-close-001");
+         * ```
+         */
+        this.commitClosePending = async (symbol, context, closeId) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_CLOSE_PENDING, {
+                symbol,
+                context,
+                closeId,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_CLOSE_PENDING);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_CLOSE_PENDING);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
                 riskName &&
-                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CANCEL);
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CLOSE_PENDING);
                 riskList &&
-                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CANCEL));
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_CLOSE_PENDING));
                 actions &&
-                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_CANCEL));
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_CLOSE_PENDING));
             }
-            await bt.strategyCoreService.cancel(true, symbol, context, cancelId);
+            await bt.strategyCoreService.closePending(true, symbol, context, closeId);
         };
         /**
          * Executes partial close at profit level (moving toward TP).
@@ -28725,7 +29314,8 @@ const LIVE_METHOD_NAME_GET_PENDING_SIGNAL = "LiveUtils.getPendingSignal";
 const LIVE_METHOD_NAME_GET_SCHEDULED_SIGNAL = "LiveUtils.getScheduledSignal";
 const LIVE_METHOD_NAME_GET_BREAKEVEN = "LiveUtils.getBreakeven";
 const LIVE_METHOD_NAME_BREAKEVEN = "Live.commitBreakeven";
-const LIVE_METHOD_NAME_CANCEL = "LiveUtils.commitCancel";
+const LIVE_METHOD_NAME_CANCEL_SCHEDULED = "Live.cancelScheduled";
+const LIVE_METHOD_NAME_CLOSE_PENDING = "Live.closePending";
 const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.commitPartialProfit";
 const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.commitPartialLoss";
 const LIVE_METHOD_NAME_TRAILING_STOP = "LiveUtils.commitTrailingStop";
@@ -28930,7 +29520,7 @@ class LiveInstance {
             }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                bt.strategyCoreService.stop(false, symbol, {
+                bt.strategyCoreService.stopStrategy(false, symbol, {
                     strategyName: context.strategyName,
                     exchangeName: context.exchangeName,
                     frameName: ""
@@ -29197,7 +29787,7 @@ class LiveUtils {
                 riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_STOP));
                 actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_STOP));
             }
-            await bt.strategyCoreService.stop(false, symbol, {
+            await bt.strategyCoreService.stopStrategy(false, symbol, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
@@ -29226,26 +29816,67 @@ class LiveUtils {
          * }, "manual-cancel-001");
          * ```
          */
-        this.commitCancel = async (symbol, context, cancelId) => {
-            bt.loggerService.info(LIVE_METHOD_NAME_CANCEL, {
+        this.commitCancelScheduled = async (symbol, context, cancelId) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_CANCEL_SCHEDULED, {
                 symbol,
                 context,
                 cancelId,
             });
-            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CANCEL);
-            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CANCEL);
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CANCEL_SCHEDULED);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CANCEL_SCHEDULED);
             {
                 const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
-                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL);
-                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL));
-                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_CANCEL));
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL_SCHEDULED);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CANCEL_SCHEDULED));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_CANCEL_SCHEDULED));
             }
-            await bt.strategyCoreService.cancel(false, symbol, {
+            await bt.strategyCoreService.cancelScheduled(false, symbol, {
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
                 frameName: "",
             }, cancelId);
         };
+        /**
+         * Closes the pending signal without stopping the strategy.
+         *
+         * Clears the pending signal (active position).
+         * Does NOT affect scheduled signals or strategy operation.
+         * Does NOT set stop flag - strategy can continue generating new signals.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @param closeId - Optional close ID for user-initiated closes
+         * @returns Promise that resolves when pending signal is closed
+         *
+         * @example
+         * ```typescript
+         * // Close pending signal with custom ID
+         * await Live.commitClose("BTCUSDT", {
+         *   exchangeName: "binance",
+         *   strategyName: "my-strategy"
+         * }, "manual-close-001");
+         * ```
+         */
+        this.commitClosePending = async (symbol, context, closeId) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_CLOSE_PENDING, {
+                symbol,
+                context,
+                closeId,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_CLOSE_PENDING);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_CLOSE_PENDING);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CLOSE_PENDING);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_CLOSE_PENDING));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_CLOSE_PENDING));
+            }
+            await bt.strategyCoreService.closePending(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }, closeId);
+        };
         /**
          * Executes partial close at profit level (moving toward TP).
          *
@@ -30162,7 +30793,7 @@ class WalkerInstance {
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
-                    bt.strategyCoreService.stop(true, symbol, {
+                    bt.strategyCoreService.stopStrategy(true, symbol, {
                         strategyName,
                         exchangeName: walkerSchema.exchangeName,
                         frameName: walkerSchema.frameName
@@ -30318,7 +30949,7 @@ class WalkerUtils {
             }
             for (const strategyName of walkerSchema.strategies) {
                 await walkerStopSubject.next({ symbol, strategyName, walkerName: context.walkerName });
-                await bt.strategyCoreService.stop(true, symbol, {
+                await bt.strategyCoreService.stopStrategy(true, symbol, {
                     strategyName,
                     exchangeName: walkerSchema.exchangeName,
                     frameName: walkerSchema.frameName
@@ -31251,6 +31882,61 @@ const CREATE_EXCHANGE_INSTANCE_FN = (schema) => {
         getOrderBook,
     };
 };
+/**
+ * Attempts to read candles from cache.
+ * Validates cache consistency (no gaps in timestamps) before returning.
+ *
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param sinceTimestamp - Start timestamp in milliseconds
+ * @param untilTimestamp - End timestamp in milliseconds
+ * @param exchangeName - Exchange name
+ * @returns Cached candles array or null if cache miss or inconsistent
+ */
+const READ_CANDLES_CACHE_FN = functoolsKit.trycatch(async (dto, sinceTimestamp, untilTimestamp, exchangeName) => {
+    const cachedCandles = await PersistCandleAdapter.readCandlesData(dto.symbol, dto.interval, exchangeName, dto.limit, sinceTimestamp, untilTimestamp);
+    // Return cached data only if we have exactly the requested limit
+    if (cachedCandles.length === dto.limit) {
+        bt.loggerService.debug(`ExchangeInstance READ_CANDLES_CACHE_FN: cache hit for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
+        return cachedCandles;
+    }
+    bt.loggerService.warn(`ExchangeInstance READ_CANDLES_CACHE_FN: cache inconsistent (count or range mismatch) for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, limit=${dto.limit}`);
+    return null;
+}, {
+    fallback: async (error) => {
+        const message = `ExchangeInstance READ_CANDLES_CACHE_FN: cache read failed`;
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
+/**
+ * Writes candles to cache with error handling.
+ *
+ * @param candles - Array of candle data to cache
+ * @param dto - Data transfer object containing symbol, interval, and limit
+ * @param exchangeName - Exchange name
+ */
+const WRITE_CANDLES_CACHE_FN = functoolsKit.trycatch(functoolsKit.queued(async (candles, dto, exchangeName) => {
+    await PersistCandleAdapter.writeCandlesData(candles, dto.symbol, dto.interval, exchangeName);
+    bt.loggerService.debug(`ExchangeInstance WRITE_CANDLES_CACHE_FN: cache updated for exchangeName=${exchangeName}, symbol=${dto.symbol}, interval=${dto.interval}, count=${candles.length}`);
+}), {
+    fallback: async (error) => {
+        const message = `ExchangeInstance WRITE_CANDLES_CACHE_FN: cache write failed`;
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
  * Instance class for exchange operations on a specific exchange.
  *
@@ -31308,6 +31994,13 @@ class ExchangeInstance {
             }
             const when = new Date(Date.now());
             const since = new Date(when.getTime() - adjust * 60 * 1000);
+            const sinceTimestamp = since.getTime();
+            const untilTimestamp = sinceTimestamp + limit * step * 60 * 1000;
+            // Try to read from cache first
+            const cachedCandles = await READ_CANDLES_CACHE_FN({ symbol, interval, limit }, sinceTimestamp, untilTimestamp, this.exchangeName);
+            if (cachedCandles !== null) {
+                return cachedCandles;
+            }
             let allData = [];
             // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
             if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
@@ -31330,7 +32023,6 @@ class ExchangeInstance {
                 allData = await getCandles(symbol, interval, since, limit, isBacktest);
             }
             // Filter candles to strictly match the requested range
-            const sinceTimestamp = since.getTime();
             const whenTimestamp = when.getTime();
             const stepMs = step * 60 * 1000;
             const filteredData = allData.filter((candle) => candle.timestamp >= sinceTimestamp && candle.timestamp < whenTimestamp + stepMs);
@@ -31342,6 +32034,8 @@ class ExchangeInstance {
             if (uniqueData.length < limit) {
                 bt.loggerService.warn(`ExchangeInstance Expected ${limit} candles, got ${uniqueData.length}`);
             }
+            // Write to cache after successful fetch
+            await WRITE_CANDLES_CACHE_FN(uniqueData, { symbol, interval, limit }, this.exchangeName);
             return uniqueData;
         };
         /**
@@ -32720,6 +33414,7 @@ exports.Partial = Partial;
 exports.Performance = Performance;
 exports.PersistBase = PersistBase;
 exports.PersistBreakevenAdapter = PersistBreakevenAdapter;
+exports.PersistCandleAdapter = PersistCandleAdapter;
 exports.PersistPartialAdapter = PersistPartialAdapter;
 exports.PersistRiskAdapter = PersistRiskAdapter;
 exports.PersistScheduleAdapter = PersistScheduleAdapter;
@@ -32739,7 +33434,8 @@ exports.addSizingSchema = addSizingSchema;
 exports.addStrategySchema = addStrategySchema;
 exports.addWalkerSchema = addWalkerSchema;
 exports.commitBreakeven = commitBreakeven;
-exports.commitCancel = commitCancel;
+exports.commitCancelScheduled = commitCancelScheduled;
+exports.commitClosePending = commitClosePending;
 exports.commitPartialLoss = commitPartialLoss;
 exports.commitPartialProfit = commitPartialProfit;
 exports.commitSignalPromptHistory = commitSignalPromptHistory;
@@ -32827,5 +33523,5 @@ exports.set = set;
 exports.setColumns = setColumns;
 exports.setConfig = setConfig;
 exports.setLogger = setLogger;
-exports.stop = stop;
+exports.stopStrategy = stopStrategy;
 exports.validate = validate;