backtest-kit 2.0.12 → 2.1.2

package/build/index.mjs

@@ -1,6 +1,6 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { Subject, trycatch, errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, retry, randomString, str, isObject, ToolRegistry, typo, and, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, iterateDocuments, distinctDocuments, queued, singlerun } from 'functools-kit';
+import { Subject, makeExtendable, singleshot, getErrorMessage, memoize, not, trycatch, retry, errorData, queued, sleep, randomString, str, isObject, ToolRegistry, typo, and, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, iterateDocuments, distinctDocuments, singlerun } from 'functools-kit';
 import * as fs from 'fs/promises';
 import fs__default, { mkdir, writeFile } from 'fs/promises';
 import path, { join, dirname } from 'path';
@@ -565,1119 +565,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__default.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__default.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__default.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__default.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__default.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: errorData(err),
-                message: getErrorMessage(err),
-            };
-            self.params.logger.warn(message, payload);
-            console.warn(message, payload);
-            lastError = err;
-            await 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 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;
 };
-/**
- * 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 = trycatch(async (self, symbol, interval, since, limit, data) => {
-    if (self.params.callbacks?.onCandleData) {
-        await self.params.callbacks.onCandleData(symbol, interval, since, limit, data);
+const BASE_WAIT_FOR_INIT_UNLINK_FN = async (filePath) => trycatch(retry(async () => {
+    try {
+        await fs__default.unlink(filePath);
+        return true;
     }
-}, {
-    fallback: (error) => {
-        const message = "ClientExchange CALL_CANDLE_DATA_CALLBACKS_FN thrown";
-        const payload = {
-            error: errorData(error),
-            message: getErrorMessage(error),
-        };
-        bt.loggerService.warn(message, payload);
-        console.warn(message, payload);
-        errorEmitter.next(error);
-    },
+    catch (error) {
+        console.error(`backtest-kit PersistBase unlink failed for filePath=${filePath} error=${getErrorMessage(error)}`);
+        throw error;
+    }
+}, BASE_UNLINK_RETRY_COUNT, BASE_UNLINK_RETRY_DELAY), {
+    defaultValue: false,
 });
 /**
- * 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 = join(process.cwd(), "logs/data")) {
+        this.entityName = entityName;
+        this.baseDir = baseDir;
+        this[_a$2] = 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 = 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 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__default.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}: ${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__default.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}: ${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}: ${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,
-        });
-        return await this.params.formatQuantity(symbol, quantity, this.params.execution.context.backtest);
+    async *keys() {
+        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_KEYS, {
+            entityName: this.entityName,
+        });
+        try {
+            const files = await fs__default.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}: ${getErrorMessage(error)}`);
+        }
     }
+}
+_a$2 = BASE_WAIT_FOR_INIT_SYMBOL;
+// @ts-ignore
+PersistBase = 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 = 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,
-            });
-        });
+        this.PersistSignalFactory = PersistBase;
+        this.getSignalStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistSignalFactory, [
+            `${symbol}_${strategyName}_${exchangeName}`,
+            `./dump/data/signal/`,
+        ]));
         /**
-         * Fetches historical candles for symbol using configured exchange.
+         * Reads persisted signal data for a symbol and strategy.
          *
-         * Routes to exchange determined by methodContextService.context.exchangeName.
+         * 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.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.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;
         };
         /**
-         * Fetches next batch of candles relative to executionContext.when.
+         * Writes signal data to disk with atomic file writes.
          *
-         * Returns candles that come after the current execution timestamp.
-         * Used for backtest progression and live trading updates.
+         * Called by ClientStrategy.setPendingSignal() to persist state.
+         * Uses atomic writes to prevent corruption on crashes.
          *
-         * @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 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.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.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 = memoize(([riskName, exchangeName]) => `${riskName}:${exchangeName}`, (riskName, exchangeName) => Reflect.construct(this.PersistRiskFactory, [
+            `${riskName}_${exchangeName}`,
+            `./dump/data/risk/`,
+        ]));
         /**
-         * Retrieves current average price for symbol.
+         * Reads persisted active positions for a risk profile.
          *
-         * In live mode: fetches real-time average price from exchange API.
-         * In backtest mode: calculates VWAP from candles in current timeframe.
+         * Called by ClientRisk.waitForInit() to restore state.
+         * Returns empty Map if no positions exist.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @returns Promise resolving to average price
+         * @param riskName - Risk profile identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise resolving to Map of active positions
          */
-        this.getAveragePrice = async (symbol) => {
-            this.loggerService.log("exchangeConnectionService getAveragePrice", {
-                symbol,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).getAveragePrice(symbol);
+        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 [];
         };
         /**
-         * Formats price according to exchange-specific precision rules.
+         * Writes active positions to disk with atomic file writes.
          *
-         * Ensures price meets exchange requirements for decimal places and tick size.
+         * 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 price - Raw price value to format
-         * @returns Promise resolving to formatted price string
+         * @param positions - Map of active positions
+         * @param riskName - Risk profile identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise that resolves when write is complete
          */
-        this.formatPrice = async (symbol, price) => {
-            this.loggerService.log("exchangeConnectionService getAveragePrice", {
-                symbol,
-                price,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).formatPrice(symbol, price);
+        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);
+    }
+}
+/**
+ * Global singleton instance of PersistRiskUtils.
+ * Used by ClientRisk for active positions persistence.
+ *
+ * @example
+ * ```typescript
+ * // Custom adapter
+ * PersistRiskAdapter.usePersistRiskAdapter(RedisPersist);
+ *
+ * // Read positions
+ * const positions = await PersistRiskAdapter.readPositionData("my-risk");
+ *
+ * // Write positions
+ * await PersistRiskAdapter.writePositionData(positionsMap, "my-risk");
+ * ```
+ */
+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 = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistScheduleFactory, [
+            `${symbol}_${strategyName}_${exchangeName}`,
+            `./dump/data/schedule/`,
+        ]));
         /**
-         * Formats quantity according to exchange-specific precision rules.
+         * Reads persisted scheduled signal data for a symbol and strategy.
          *
-         * Ensures quantity meets exchange requirements for decimal places and lot size.
+         * Called by ClientStrategy.waitForInit() to restore scheduled signal state.
+         * Returns null if no scheduled signal exists.
          *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param quantity - Raw quantity value to format
-         * @returns Promise resolving to formatted quantity string
+         * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param exchangeName - Exchange identifier
+         * @returns Promise resolving to scheduled signal or null
          */
-        this.formatQuantity = async (symbol, quantity) => {
-            this.loggerService.log("exchangeConnectionService getAveragePrice", {
-                symbol,
-                quantity,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).formatQuantity(symbol, quantity);
+        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;
         };
         /**
-         * Fetches order book for a trading pair using configured exchange.
+         * Writes scheduled signal data 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 ClientStrategy.setScheduledSignal() 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 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.getOrderBook = async (symbol, depth) => {
-            this.loggerService.log("exchangeConnectionService getOrderBook", {
-                symbol,
-                depth,
-            });
-            return await this.getExchange(this.methodContextService.context.exchangeName).getOrderBook(symbol, depth);
+        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);
         };
     }
-}
-
-/**
- * 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,
-        };
-    }
-    // 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.
- *
- * @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
+ * Global singleton instance of PersistScheduleUtils.
+ * Used by ClientStrategy for scheduled signal persistence.
  *
  * @example
- * // Using encoding shorthand
- * await writeFileAtomic("log.txt", "Log entry", "utf16le");
- * // Writes "Log entry" to "log.txt" in UTF-16LE encoding
+ * ```typescript
+ * // Custom adapter
+ * PersistScheduleAdapter.usePersistScheduleAdapter(RedisPersist);
  *
- * @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.
+ * // Read scheduled signal
+ * const scheduled = await PersistScheduleAdapter.readScheduleData("my-strategy", "BTCUSDT");
  *
- * @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__default.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__default.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__default.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__default.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__default.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 not(BASE_WAIT_FOR_INIT_UNLINK_FN(filePath))) {
-                console.error(`backtest-kit PersistBase failed to remove invalid document for filePath=${filePath} entityName=${self.entityName}`);
-            }
-        }
-    }
-};
-const BASE_WAIT_FOR_INIT_UNLINK_FN = async (filePath) => trycatch(retry(async () => {
-    try {
-        await fs__default.unlink(filePath);
-        return true;
-    }
-    catch (error) {
-        console.error(`backtest-kit PersistBase unlink failed for filePath=${filePath} error=${getErrorMessage(error)}`);
-        throw error;
-    }
-}, BASE_UNLINK_RETRY_COUNT, BASE_UNLINK_RETRY_DELAY), {
-    defaultValue: false,
-});
+ * // Write scheduled signal
+ * await PersistScheduleAdapter.writeScheduleData(scheduled, "my-strategy", "BTCUSDT");
+ * ```
+ */
+const PersistScheduleAdapter = new PersistScheduleUtils();
 /**
- * Base class for file-based persistence with atomic writes.
+ * Utility class for managing partial profit/loss levels persistence.
  *
  * Features:
- * - Atomic file writes using writeFileAtomic
- * - Auto-validation and cleanup of corrupted files
- * - Async generator support for iteration
- * - Retry logic for file deletion
+ * - Memoized storage instances per symbol:strategyName
+ * - Custom adapter support
+ * - Atomic read/write operations for partial data
+ * - Crash-safe partial state management
  *
- * @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");
- * ```
+ * Used by ClientPartial for live mode persistence of profit/loss levels.
  */
-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 = join(process.cwd(), "logs/data")) {
-        this.entityName = entityName;
-        this.baseDir = baseDir;
-        this[_a$2] = singleshot(async () => await BASE_WAIT_FOR_INIT_FN(this));
-        bt.loggerService.debug(PERSIST_BASE_METHOD_NAME_CTOR, {
-            entityName: this.entityName,
-            baseDir,
-        });
-        this._directory = 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 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__default.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}: ${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__default.access(filePath);
-            return true;
-        }
-        catch (error) {
-            if (error?.code === "ENOENT") {
-                return false;
+class PersistPartialUtils {
+    constructor() {
+        this.PersistPartialFactory = PersistBase;
+        this.getPartialStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistPartialFactory, [
+            `${symbol}_${strategyName}_${exchangeName}`,
+            `./dump/data/partial/`,
+        ]));
+        /**
+         * Reads persisted partial data for a symbol and strategy.
+         *
+         * Called by ClientPartial.waitForInit() to restore state.
+         * Returns empty object if no partial data exists.
+         *
+         * @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);
             }
-            throw new Error(`Failed to check existence of entity ${this.entityName}:${entityId}: ${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}: ${getErrorMessage(error)}`);
-        }
+            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);
+        };
     }
     /**
-     * Async generator yielding all entity IDs.
-     * Sorted alphanumerically.
-     * Used internally by waitForInit for validation.
+     * Registers a custom persistence adapter.
      *
-     * @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__default.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}: ${getErrorMessage(error)}`);
-        }
-    }
-}
-_a$2 = BASE_WAIT_FOR_INIT_SYMBOL;
-// @ts-ignore
-PersistBase = 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
+     * @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);
+     * ```
      */
-    async readValue() {
-        return {};
+    usePersistPartialAdapter(Ctor) {
+        bt.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_PERSIST_PARTIAL_ADAPTER);
+        this.PersistPartialFactory = Ctor;
     }
     /**
-     * No-op has value check.
-     * @returns Promise that resolves to false
+     * Switches to the default JSON persist adapter.
+     * All future persistence writes will use JSON storage.
      */
-    async hasValue() {
-        return false;
+    useJson() {
+        bt.loggerService.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_JSON);
+        this.usePersistPartialAdapter(PersistBase);
     }
-    /**
-     * No-op write function.
-     * @returns Promise that resolves immediately
+    /**
+     * Switches to a dummy persist adapter that discards all writes.
+     * All future persistence writes will be no-ops.
      */
-    async writeValue() {
+    useDummy() {
+        bt.loggerService.log(PERSIST_PARTIAL_UTILS_METHOD_NAME_USE_DUMMY);
+        this.usePersistPartialAdapter(PersistDummy);
     }
 }
 /**
- * Utility class for managing signal persistence.
+ * 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:
- * - Memoized storage instances per strategy
- * - Custom adapter support
- * - Atomic read/write operations
- * - Crash-safe signal state management
+ * - Atomic file writes via PersistBase.writeValue()
+ * - Lazy initialization on first access
+ * - Singleton pattern for global access
+ * - Custom adapter support via usePersistBreakevenAdapter()
  *
- * Used by ClientStrategy for live mode persistence.
+ * File structure:
+ * ```
+ * ./dump/data/breakeven/
+ * ├── BTCUSDT_my-strategy/
+ * │   └── state.json        // { "signal-id-1": { reached: true }, ... }
+ * └── ETHUSDT_other-strategy/
+ *     └── state.json
+ * ```
+ *
+ * @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");
+ * ```
  */
-class PersistSignalUtils {
+class PersistBreakevenUtils {
     constructor() {
-        this.PersistSignalFactory = PersistBase;
-        this.getSignalStorage = 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 = 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);
         };
     }
     /**
@@ -1691,538 +1471,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 = memoize(([riskName, exchangeName]) => `${riskName}:${exchangeName}`, (riskName, exchangeName) => Reflect.construct(this.PersistRiskFactory, [
-            `${riskName}_${exchangeName}`,
-            `./dump/data/risk/`,
+        this.PersistCandlesFactory = PersistBase;
+        this.getCandlesStorage = 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.
+         * Reads cached candles for a specific exchange, symbol, and interval.
+         * Returns candles only if cache contains exactly the requested limit.
          *
-         * Called by ClientRisk.waitForInit() to restore state.
-         * Returns empty Map if no positions exist.
+         * @param symbol - Trading pair symbol
+         * @param interval - Candle interval
+         * @param exchangeName - Exchange identifier
+         * @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.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);
+            // 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 candles to cache with atomic file writes.
+         * Each candle is stored as a separate JSON file named by its timestamp.
          *
-         * @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 resolving to Map of active positions
+         * @returns Promise that resolves when all writes are complete
          */
-        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.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";
-            if (await stateStorage.hasValue(RISK_STORAGE_KEY)) {
-                return await stateStorage.readValue(RISK_STORAGE_KEY);
+            // Write each candle as a separate file
+            for (const candle of candles) {
+                if (await not(stateStorage.hasValue(String(candle.timestamp)))) {
+                    await stateStorage.writeValue(String(candle.timestamp), candle);
+                }
+            }
+        };
+    }
+    /**
+     * Registers a custom persistence adapter.
+     *
+     * @param Ctor - Custom PersistBase constructor
+     */
+    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("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("PersistCandleUtils.useDummy");
+        this.usePersistCandleAdapter(PersistDummy);
+    }
+}
+/**
+ * Global singleton instance of PersistCandleUtils.
+ * Used by ClientExchange for candle data caching.
+ *
+ * @example
+ * ```typescript
+ * // Read cached candles
+ * const candles = await PersistCandleAdapter.readCandlesData(
+ *   "BTCUSDT", "1m", "binance", 100, since.getTime(), until.getTime()
+ * );
+ *
+ * // Write candles to cache
+ * await PersistCandleAdapter.writeCandlesData(candles, "BTCUSDT", "1m", "binance");
+ * ```
+ */
+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,
+};
+/**
+ * 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.
+ *
+ * @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;
+    }
+    // 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 {
+        // 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;
+    }
+    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}`);
+        }
+    }
+};
+/**
+ * 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 self - Instance of ClientExchange
+ * @returns Cached candles array or null if cache miss or inconsistent
+ */
+const READ_CANDLES_CACHE_FN$1 = 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: errorData(error),
+            message: 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 self - Instance of ClientExchange
+ */
+const WRITE_CANDLES_CACHE_FN$1 = trycatch(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: errorData(error),
+            message: getErrorMessage(error),
+        };
+        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: errorData(err),
+                message: getErrorMessage(err),
+            };
+            self.params.logger.warn(message, payload);
+            console.warn(message, payload);
+            lastError = err;
+            await 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 = 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: errorData(error),
+            message: 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);
+                }
             }
-            return [];
-        };
-        /**
-         * 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.
-         *
-         * @param positions - Map of active positions
-         * @param riskName - Risk profile identifier
-         * @param exchangeName - Exchange identifier
-         * @returns Promise that resolves when write is 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);
-            await stateStorage.waitForInit(isInitial);
-            const RISK_STORAGE_KEY = "positions";
-            await stateStorage.writeValue(RISK_STORAGE_KEY, riskRow);
-        };
+        }
+        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;
     }
     /**
-     * Registers a custom persistence adapter.
+     * 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.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * Formula:
+     * - Typical Price = (high + low + close) / 3
+     * - VWAP = sum(typical_price * volume) / sum(volume)
      *
-     * @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);
-     * ```
+     * 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
      */
-    usePersistRiskAdapter(Ctor) {
-        bt.loggerService.info(PERSIST_RISK_UTILS_METHOD_NAME_USE_PERSIST_RISK_ADAPTER);
-        this.PersistRiskFactory = Ctor;
+    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;
     }
     /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * 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 symbol - Trading pair symbol
+     * @param quantity - Raw quantity to format
+     * @returns Promise resolving to formatted quantity as string
      */
-    useJson() {
-        bt.loggerService.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistRiskAdapter(PersistBase);
+    async formatQuantity(symbol, quantity) {
+        this.params.logger.debug("binanceService formatQuantity", {
+            symbol,
+            quantity,
+        });
+        return await this.params.formatQuantity(symbol, quantity, this.params.execution.context.backtest);
     }
     /**
-     * Switches to a dummy persist adapter that discards all writes.
-     * All future persistence writes will be no-ops.
+     * 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
      */
-    useDummy() {
-        bt.loggerService.log(PERSIST_RISK_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistRiskAdapter(PersistDummy);
-    }
-}
-/**
- * Global singleton instance of PersistRiskUtils.
- * Used by ClientRisk for active positions persistence.
- *
- * @example
- * ```typescript
- * // Custom adapter
- * PersistRiskAdapter.usePersistRiskAdapter(RedisPersist);
- *
- * // Read positions
- * const positions = await PersistRiskAdapter.readPositionData("my-risk");
- *
- * // Write positions
- * await PersistRiskAdapter.writePositionData(positionsMap, "my-risk");
- * ```
- */
-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 = 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);
-        };
+    async formatPrice(symbol, price) {
+        this.params.logger.debug("binanceService formatPrice", {
+            symbol,
+            price,
+        });
+        return await this.params.formatPrice(symbol, price, this.params.execution.context.backtest);
     }
     /**
-     * Registers a custom persistence adapter.
+     * Fetches raw candles with flexible date/limit parameters.
      *
-     * @param Ctor - Custom PersistBase constructor
+     * 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
      *
-     * @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;
-    }
-    /**
-     * Switches to the default JSON persist adapter.
-     * All future persistence writes will use JSON storage.
+     * 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_SCHEDULE_UTILS_METHOD_NAME_USE_JSON);
-        this.usePersistScheduleAdapter(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_SCHEDULE_UTILS_METHOD_NAME_USE_DUMMY);
-        this.usePersistScheduleAdapter(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 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");
- *
- * // Write scheduled signal
- * await PersistScheduleAdapter.writeScheduleData(scheduled, "my-strategy", "BTCUSDT");
- * ```
+ * Default implementation for getCandles.
+ * Throws an error indicating the method is not implemented.
  */
-const PersistScheduleAdapter = new PersistScheduleUtils();
+const DEFAULT_GET_CANDLES_FN$1 = async (_symbol, _interval, _since, _limit, _backtest) => {
+    throw new Error(`getCandles is not implemented for this exchange`);
+};
 /**
- * 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
- *
- * Used by ClientPartial for live mode persistence of profit/loss levels.
+ * Default implementation for formatQuantity.
+ * Returns Bitcoin precision on Binance (8 decimal places).
  */
-class PersistPartialUtils {
-    constructor() {
-        this.PersistPartialFactory = PersistBase;
-        this.getPartialStorage = memoize(([symbol, strategyName, exchangeName]) => `${symbol}:${strategyName}:${exchangeName}`, (symbol, strategyName, exchangeName) => Reflect.construct(this.PersistPartialFactory, [
-            `${symbol}_${strategyName}_${exchangeName}`,
-            `./dump/data/partial/`,
-        ]));
-        /**
-         * Reads persisted partial data for a symbol and strategy.
-         *
-         * Called by ClientPartial.waitForInit() to restore state.
-         * Returns empty object if no partial data exists.
-         *
-         * @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);
-        };
-    }
-    /**
-     * 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;
-    }
-    /**
-     * 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);
-    }
-    /**
-     * 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);
-    }
-}
+const DEFAULT_FORMAT_QUANTITY_FN$1 = async (_symbol, quantity, _backtest) => {
+    return quantity.toFixed(8);
+};
 /**
- * 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 formatPrice.
+ * Returns Bitcoin precision on Binance (2 decimal places).
  */
-const PersistPartialAdapter = new PersistPartialUtils();
+const DEFAULT_FORMAT_PRICE_FN$1 = async (_symbol, price, _backtest) => {
+    return price.toFixed(2);
+};
 /**
- * Persistence utility class for breakeven state management.
+ * 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 = 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 = 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);
         };
-    }
-    /**
-     * 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;
-    }
-    /**
-     * 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);
-    }
-    /**
-     * 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);
     }
 }
+
 /**
- * Global singleton instance of PersistBreakevenUtils.
- * Used by ClientBreakeven for breakeven state persistence.
+ * 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
- * // Custom adapter
- * PersistBreakevenAdapter.usePersistBreakevenAdapter(RedisPersist);
- *
- * // Read breakeven data
- * const breakevenData = await PersistBreakevenAdapter.readBreakevenData("BTCUSDT", "my-strategy");
+ * // 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)
  *
- * // Write breakeven data
- * await PersistBreakevenAdapter.writeBreakevenData(breakevenData, "BTCUSDT", "my-strategy");
+ * // 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 PersistBreakevenAdapter = new PersistBreakevenUtils();
+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,
+        };
+    }
+    // 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);
+    }
+    // Применяем комиссию дважды (при открытии и закрытии)
+    const totalFee = GLOBAL_CONFIG.CC_PERCENT_FEE * 2;
+    let pnlPercentage;
+    if (signal.position === "long") {
+        // LONG: прибыль при росте цены
+        pnlPercentage =
+            ((priceCloseWithSlippage - priceOpenWithSlippage) /
+                priceOpenWithSlippage) *
+                100;
+    }
+    else {
+        // SHORT: прибыль при падении цены
+        pnlPercentage =
+            ((priceOpenWithSlippage - priceCloseWithSlippage) /
+                priceOpenWithSlippage) *
+                100;
+    }
+    // Вычитаем комиссии
+    pnlPercentage -= totalFee;
+    return {
+        pnlPercentage,
+        priceOpen,
+        priceClose,
+    };
+};
 
 /**
  * Converts markdown content to plain text with minimal formatting
@@ -4389,6 +4740,7 @@ class ClientStrategy {
         this._lastSignalTimestamp = null;
         this._scheduledSignal = null;
         this._cancelledSignal = null;
+        this._closedSignal = null;
         /**
          * Initializes strategy state by loading persisted signal from disk.
          *
@@ -4665,6 +5017,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
@@ -4778,8 +5165,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");
         }
@@ -4906,12 +5325,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,
@@ -4944,12 +5363,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,
@@ -4966,6 +5385,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).
      *
@@ -6418,7 +6876,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
@@ -6426,13 +6884,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.
@@ -6484,7 +6942,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
@@ -6496,14 +6954,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).
@@ -9690,19 +10173,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.
          *
@@ -9712,15 +10195,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.
@@ -25006,7 +25516,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";
@@ -25028,26 +25539,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).
@@ -25294,7 +25841,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.
  *
@@ -25316,8 +25863,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()) {
@@ -25328,7 +25875,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,
@@ -27715,7 +28262,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";
@@ -27957,7 +28505,7 @@ class BacktestInstance {
             }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
-                bt.strategyCoreService.stop(true, symbol, {
+                bt.strategyCoreService.stopStrategy(true, symbol, {
                     strategyName: context.strategyName,
                     exchangeName: context.exchangeName,
                     frameName: context.frameName,
@@ -28225,7 +28773,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.
@@ -28250,24 +28798,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).
@@ -28704,7 +29293,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";
@@ -28909,7 +29499,7 @@ class LiveInstance {
             }
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(getErrorMessage(error))));
             return () => {
-                bt.strategyCoreService.stop(false, symbol, {
+                bt.strategyCoreService.stopStrategy(false, symbol, {
                     strategyName: context.strategyName,
                     exchangeName: context.exchangeName,
                     frameName: ""
@@ -29176,7 +29766,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: "",
@@ -29205,26 +29795,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).
          *
@@ -30141,7 +30772,7 @@ class WalkerInstance {
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(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
@@ -30297,7 +30928,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
@@ -31230,6 +31861,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 = 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: errorData(error),
+            message: 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 = trycatch(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: errorData(error),
+            message: 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.
  *
@@ -31287,6 +31973,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) {
@@ -31309,7 +32002,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);
@@ -31321,6 +32013,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;
         };
         /**
@@ -32680,4 +33374,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addOptimizerSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancel, commitPartialLoss, commitPartialProfit, commitSignalPromptHistory, commitTrailingStop, commitTrailingTake, dumpSignalData, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOptimizerSchema, getOrderBook, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listOptimizerSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideOptimizerSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stop, validate };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Optimizer, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addOptimizerSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitSignalPromptHistory, commitTrailingStop, commitTrailingTake, dumpSignalData, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOptimizerSchema, getOrderBook, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listOptimizerSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideOptimizerSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };