backtest-kit 2.3.1 → 2.3.3

package/build/index.mjs

@@ -1,6 +1,6 @@
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
-import { Subject, makeExtendable, singleshot, getErrorMessage, memoize, errorData, not, trycatch, retry, queued, sleep, randomString, str, isObject, ToolRegistry, typo, and, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, singlerun } from 'functools-kit';
+import { Subject, makeExtendable, singleshot, getErrorMessage, memoize, not, errorData, trycatch, retry, queued, sleep, randomString, str, isObject, ToolRegistry, typo, and, resolveDocuments, timeout, TIMEOUT_SYMBOL as TIMEOUT_SYMBOL$1, compose, singlerun } from 'functools-kit';
 import * as fs from 'fs/promises';
 import fs__default from 'fs/promises';
 import path, { join, dirname } from 'path';
@@ -1558,73 +1558,73 @@ class PersistCandleUtils {
         ]));
         /**
          * Reads cached candles for a specific exchange, symbol, and interval.
-         * Returns candles only if cache contains exactly the requested limit.
+         * Returns candles only if cache contains ALL requested candles.
          *
-         * Boundary semantics (EXCLUSIVE):
-         * - sinceTimestamp: candle.timestamp must be > sinceTimestamp
-         * - untilTimestamp: candle.timestamp + stepMs must be < untilTimestamp
-         * - Only fully closed candles within the exclusive range are returned
+         * Algorithm (matches ClientExchange.ts logic):
+         * 1. Calculate expected timestamps: sinceTimestamp, sinceTimestamp + stepMs, ..., sinceTimestamp + (limit-1) * stepMs
+         * 2. Try to read each expected candle by timestamp key
+         * 3. If ANY candle is missing, return null (cache miss)
+         * 4. If all candles found, return them in order
          *
          * @param symbol - Trading pair symbol
          * @param interval - Candle interval
          * @param exchangeName - Exchange identifier
          * @param limit - Number of candles requested
-         * @param sinceTimestamp - Exclusive start timestamp in milliseconds
-         * @param untilTimestamp - Exclusive end timestamp in milliseconds
+         * @param sinceTimestamp - Aligned start timestamp (openTime of first candle)
+         * @param _untilTimestamp - Unused, kept for API compatibility
          * @returns Promise resolving to array of candles or null if cache is incomplete
          */
-        this.readCandlesData = async (symbol, interval, exchangeName, limit, sinceTimestamp, untilTimestamp) => {
+        this.readCandlesData = async (symbol, interval, exchangeName, limit, sinceTimestamp, _untilTimestamp) => {
             bt.loggerService.info("PersistCandleUtils.readCandlesData", {
                 symbol,
                 interval,
                 exchangeName,
                 limit,
                 sinceTimestamp,
-                untilTimestamp,
             });
             const key = `${symbol}:${interval}:${exchangeName}`;
             const isInitial = !this.getCandlesStorage.has(key);
             const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
             await stateStorage.waitForInit(isInitial);
             const stepMs = INTERVAL_MINUTES$5[interval] * MS_PER_MINUTE$2;
-            // Collect all cached candles within the time range using EXCLUSIVE boundaries
+            // Calculate expected timestamps and fetch each candle directly
             const cachedCandles = [];
-            for await (const timestamp of stateStorage.keys()) {
-                const ts = Number(timestamp);
-                // EXCLUSIVE boundaries:
-                // - candle.timestamp > sinceTimestamp
-                // - candle.timestamp + stepMs < untilTimestamp (fully closed before untilTimestamp)
-                if (ts > sinceTimestamp && ts + stepMs < untilTimestamp) {
-                    try {
-                        const candle = await stateStorage.readValue(timestamp);
-                        cachedCandles.push(candle);
-                    }
-                    catch (error) {
-                        const message = `PersistCandleUtils.readCandlesData found invalid candle symbol=${symbol} interval=${interval} timestamp=${timestamp}`;
-                        const payload = {
-                            error: errorData(error),
-                            message: getErrorMessage(error),
-                        };
-                        bt.loggerService.warn(message, payload);
-                        console.warn(message, payload);
-                        errorEmitter.next(error);
-                        continue;
-                    }
+            for (let i = 0; i < limit; i++) {
+                const expectedTimestamp = sinceTimestamp + i * stepMs;
+                const timestampKey = String(expectedTimestamp);
+                if (await not(stateStorage.hasValue(timestampKey))) {
+                    // Cache miss - candle not found
+                    return null;
+                }
+                try {
+                    const candle = await stateStorage.readValue(timestampKey);
+                    cachedCandles.push(candle);
+                }
+                catch (error) {
+                    // Invalid candle in cache - treat as cache miss
+                    const message = `PersistCandleUtils.readCandlesData found invalid candle symbol=${symbol} interval=${interval} timestamp=${expectedTimestamp}`;
+                    const payload = {
+                        error: errorData(error),
+                        message: getErrorMessage(error),
+                    };
+                    bt.loggerService.warn(message, payload);
+                    console.warn(message, payload);
+                    errorEmitter.next(error);
+                    return null;
                 }
             }
-            // 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.
          *
-         * The candles passed to this function must already be filtered using EXCLUSIVE boundaries:
-         * - candle.timestamp > sinceTimestamp
-         * - candle.timestamp + stepMs < untilTimestamp
+         * The candles passed to this function should be validated candles from the adapter:
+         * - First candle.timestamp equals aligned sinceTimestamp (openTime)
+         * - Exact number of candles as requested
+         * - All candles are fully closed (timestamp + stepMs < untilTimestamp)
          *
-         * @param candles - Array of candle data to cache (already filtered with exclusive boundaries)
+         * @param candles - Array of candle data to cache (validated by the caller)
          * @param symbol - Trading pair symbol
          * @param interval - Candle interval
          * @param exchangeName - Exchange identifier
@@ -1641,8 +1641,25 @@ class PersistCandleUtils {
             const isInitial = !this.getCandlesStorage.has(key);
             const stateStorage = this.getCandlesStorage(symbol, interval, exchangeName);
             await stateStorage.waitForInit(isInitial);
-            // Write each candle as a separate file
+            // Calculate step in milliseconds to determine candle close time
+            const stepMs = INTERVAL_MINUTES$5[interval] * MS_PER_MINUTE$2;
+            const now = Date.now();
+            // Write each candle as a separate file, skipping incomplete candles
             for (const candle of candles) {
+                // Skip incomplete candles: candle is complete when closeTime <= now
+                // closeTime = timestamp + stepMs
+                const candleCloseTime = candle.timestamp + stepMs;
+                if (candleCloseTime > now) {
+                    bt.loggerService.debug("PersistCandleUtils.writeCandlesData: skipping incomplete candle", {
+                        symbol,
+                        interval,
+                        exchangeName,
+                        timestamp: candle.timestamp,
+                        closeTime: candleCloseTime,
+                        now,
+                    });
+                    continue;
+                }
                 if (await not(stateStorage.hasValue(String(candle.timestamp)))) {
                     await stateStorage.writeValue(String(candle.timestamp), candle);
                 }
@@ -1800,6 +1817,27 @@ const INTERVAL_MINUTES$4 = {
     "6h": 360,
     "8h": 480,
 };
+/**
+ * Aligns timestamp down to the nearest interval boundary.
+ * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
+ *
+ * Candle timestamp convention:
+ * - Candle timestamp = openTime (when candle opens)
+ * - Candle with timestamp 00:00 covers period [00:00, 00:15) for 15m interval
+ *
+ * Adapter contract:
+ * - Adapter must return candles with timestamp = openTime
+ * - First returned candle.timestamp must equal aligned since
+ * - Adapter must return exactly `limit` candles
+ *
+ * @param timestamp - Timestamp in milliseconds
+ * @param intervalMinutes - Interval in minutes
+ * @returns Aligned timestamp rounded down to interval boundary
+ */
+const ALIGN_TO_INTERVAL_FN$1 = (timestamp, intervalMinutes) => {
+    const intervalMs = intervalMinutes * MS_PER_MINUTE$1;
+    return Math.floor(timestamp / intervalMs) * intervalMs;
+};
 /**
  * Validates that all candles have valid OHLCV data without anomalies.
  * Detects incomplete candles from Binance API by checking for abnormally low prices or volumes.
@@ -1863,25 +1901,24 @@ const VALIDATE_NO_INCOMPLETE_CANDLES_FN = (candles) => {
 };
 /**
  * Attempts to read candles from cache.
- * Validates cache consistency (no gaps in timestamps) before returning.
  *
- * Boundary semantics:
- * - sinceTimestamp: EXCLUSIVE lower bound (candle.timestamp > sinceTimestamp)
- * - untilTimestamp: EXCLUSIVE upper bound (candle.timestamp + stepMs < untilTimestamp)
- * - Only fully closed candles within the exclusive range are returned
+ * Cache lookup calculates expected timestamps:
+ * sinceTimestamp + i * stepMs for i = 0..limit-1
+ * Returns all candles if found, null if any missing.
  *
  * @param dto - Data transfer object containing symbol, interval, and limit
- * @param sinceTimestamp - Exclusive start timestamp in milliseconds
- * @param untilTimestamp - Exclusive end timestamp in milliseconds
+ * @param sinceTimestamp - Aligned start timestamp (openTime of first candle)
+ * @param untilTimestamp - Unused, kept for API compatibility
  * @param self - Instance of ClientExchange
- * @returns Cached candles array or null if cache miss or inconsistent
+ * @returns Cached candles array (exactly limit) or null if cache miss
  */
 const READ_CANDLES_CACHE_FN$1 = trycatch(async (dto, sinceTimestamp, untilTimestamp, self) => {
-    // PersistCandleAdapter.readCandlesData uses EXCLUSIVE boundaries:
-    // Returns candles where: timestamp > sinceTimestamp AND timestamp + stepMs < untilTimestamp
+    // PersistCandleAdapter.readCandlesData calculates expected timestamps:
+    // sinceTimestamp + i * stepMs for i = 0..limit-1
+    // Returns all candles if found, null if any missing
     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) {
+    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;
     }
@@ -1903,11 +1940,12 @@ const READ_CANDLES_CACHE_FN$1 = trycatch(async (dto, sinceTimestamp, untilTimest
 /**
  * Writes candles to cache with error handling.
  *
- * The candles passed to this function must already be filtered using EXCLUSIVE boundaries:
- * - candle.timestamp > sinceTimestamp
- * - candle.timestamp + stepMs < untilTimestamp
+ * The candles passed to this function should be validated:
+ * - First candle.timestamp equals aligned sinceTimestamp (openTime)
+ * - Exact number of candles as requested (limit)
+ * - Sequential timestamps: sinceTimestamp + i * stepMs
  *
- * @param candles - Array of candle data to cache (already filtered with exclusive boundaries)
+ * @param candles - Array of validated candle data to cache
  * @param dto - Data transfer object containing symbol, interval, and limit
  * @param self - Instance of ClientExchange
  */
@@ -2034,6 +2072,13 @@ class ClientExchange {
     /**
      * Fetches historical candles backwards from execution context time.
      *
+     * Algorithm:
+     * 1. Align when down to interval boundary (e.g., 00:17 -> 00:15 for 15m)
+     * 2. Calculate since = alignedWhen - limit * step
+     * 3. Fetch candles starting from since
+     * 4. Validate first candle timestamp matches since (adapter must return inclusive data)
+     * 5. Slice to limit
+     *
      * @param symbol - Trading pair symbol
      * @param interval - Candle interval
      * @param limit - Number of candles to fetch
@@ -2046,11 +2091,16 @@ class ClientExchange {
             limit,
         });
         const step = INTERVAL_MINUTES$4[interval];
-        const adjust = step * limit;
-        if (!adjust) {
-            throw new Error(`ClientExchange unknown time adjust for interval=${interval}`);
+        if (!step) {
+            throw new Error(`ClientExchange unknown interval=${interval}`);
         }
-        const since = new Date(this.params.execution.context.when.getTime() - adjust * MS_PER_MINUTE$1);
+        const stepMs = step * MS_PER_MINUTE$1;
+        // Align when down to interval boundary
+        const whenTimestamp = this.params.execution.context.when.getTime();
+        const alignedWhen = ALIGN_TO_INTERVAL_FN$1(whenTimestamp, step);
+        // Calculate since: go back limit candles from aligned when
+        const sinceTimestamp = alignedWhen - limit * stepMs;
+        const since = new Date(sinceTimestamp);
         let allData = [];
         // If limit exceeds CC_MAX_CANDLES_PER_REQUEST, fetch data in chunks
         if (limit > GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST) {
@@ -2063,39 +2113,34 @@ class ClientExchange {
                 remaining -= chunkLimit;
                 if (remaining > 0) {
                     // Move currentSince forward by the number of candles fetched
-                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE$1);
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
                 }
             }
         }
         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 * MS_PER_MINUTE$1;
-        const filteredData = allData.filter((candle) => {
-            // EXCLUSIVE boundaries:
-            // - candle.timestamp > sinceTimestamp (exclude exact boundary)
-            // - candle.timestamp + stepMs < whenTimestamp (fully closed before "when")
-            if (candle.timestamp <= sinceTimestamp) {
-                return false;
-            }
-            // Check against current time (when)
-            // Only allow candles that have fully CLOSED before "when"
-            return candle.timestamp + stepMs < 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`;
+        const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
+        if (allData.length !== uniqueData.length) {
+            const msg = `ClientExchange getCandles: Removed ${allData.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);
+        // Validate adapter returned data
+        if (uniqueData.length === 0) {
+            throw new Error(`ClientExchange getCandles: adapter returned empty array. ` +
+                `Expected ${limit} candles starting from openTime=${sinceTimestamp}.`);
+        }
+        if (uniqueData[0].timestamp !== sinceTimestamp) {
+            throw new Error(`ClientExchange getCandles: first candle timestamp mismatch. ` +
+                `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
+                `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
+        }
+        if (uniqueData.length !== limit) {
+            throw new Error(`ClientExchange getCandles: candle count mismatch. ` +
+                `Expected ${limit} candles, got ${uniqueData.length}. ` +
+                `Adapter must return exact number of candles requested.`);
         }
         await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, uniqueData);
         return uniqueData;
@@ -2104,6 +2149,13 @@ class ClientExchange {
      * Fetches future candles forwards from execution context time.
      * Used in backtest mode to get candles for signal duration.
      *
+     * Algorithm:
+     * 1. Align when down to interval boundary (e.g., 00:17 -> 00:15 for 15m)
+     * 2. since = alignedWhen (start from aligned when)
+     * 3. Fetch candles starting from since
+     * 4. Validate first candle timestamp matches since (adapter must return inclusive data)
+     * 5. Slice to limit
+     *
      * @param symbol - Trading pair symbol
      * @param interval - Candle interval
      * @param limit - Number of candles to fetch
@@ -2119,12 +2171,21 @@ class ClientExchange {
         if (!this.params.execution.context.backtest) {
             throw new Error(`ClientExchange getNextCandles: cannot fetch future candles in live mode`);
         }
-        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 * MS_PER_MINUTE$1;
-        // Проверяем что запрошенный период не заходит за Date.now()
+        if (!step) {
+            throw new Error(`ClientExchange getNextCandles: unknown interval=${interval}`);
+        }
+        const stepMs = step * MS_PER_MINUTE$1;
+        const now = Date.now();
+        // Align when down to interval boundary
+        const whenTimestamp = this.params.execution.context.when.getTime();
+        const alignedWhen = ALIGN_TO_INTERVAL_FN$1(whenTimestamp, step);
+        // since = alignedWhen (start from aligned when, going forward)
+        const sinceTimestamp = alignedWhen;
+        const since = new Date(sinceTimestamp);
+        // Calculate end time for Date.now() check
+        const endTime = sinceTimestamp + limit * stepMs;
+        // Check that requested period does not exceed Date.now()
         if (endTime > now) {
             return [];
         }
@@ -2140,29 +2201,34 @@ class ClientExchange {
                 remaining -= chunkLimit;
                 if (remaining > 0) {
                     // Move currentSince forward by the number of candles fetched
-                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE$1);
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
                 }
             }
         }
         else {
             allData = await GET_CANDLES_FN({ symbol, interval, limit }, since, this);
         }
-        // Filter candles to strictly match the requested range
-        const sinceTimestamp = since.getTime();
-        const stepMs = step * MS_PER_MINUTE$1;
-        const filteredData = allData.filter((candle) => candle.timestamp > sinceTimestamp &&
-            candle.timestamp + stepMs < 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`;
+        const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
+        if (allData.length !== uniqueData.length) {
+            const msg = `ClientExchange getNextCandles: Removed ${allData.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);
+        // Validate adapter returned data
+        if (uniqueData.length === 0) {
+            throw new Error(`ClientExchange getNextCandles: adapter returned empty array. ` +
+                `Expected ${limit} candles starting from openTime=${sinceTimestamp}.`);
+        }
+        if (uniqueData[0].timestamp !== sinceTimestamp) {
+            throw new Error(`ClientExchange getNextCandles: first candle timestamp mismatch. ` +
+                `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
+                `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
+        }
+        if (uniqueData.length !== limit) {
+            throw new Error(`ClientExchange getNextCandles: candle count mismatch. ` +
+                `Expected ${limit} candles, got ${uniqueData.length}. ` +
+                `Adapter must return exact number of candles requested.`);
         }
         await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, limit, uniqueData);
         return uniqueData;
@@ -2237,6 +2303,12 @@ class ClientExchange {
     /**
      * Fetches raw candles with flexible date/limit parameters.
      *
+     * Algorithm:
+     * 1. Align all timestamps down to interval boundary
+     * 2. Fetch candles starting from aligned since
+     * 3. Validate first candle timestamp matches aligned since (adapter must return inclusive data)
+     * 4. Slice to limit
+     *
      * All modes respect execution context and prevent look-ahead bias.
      *
      * Parameter combinations:
@@ -2271,9 +2343,10 @@ class ClientExchange {
         if (!step) {
             throw new Error(`ClientExchange getRawCandles: unknown interval=${interval}`);
         }
+        const stepMs = step * MS_PER_MINUTE$1;
         const whenTimestamp = this.params.execution.context.when.getTime();
+        const alignedWhen = ALIGN_TO_INTERVAL_FN$1(whenTimestamp, step);
         let sinceTimestamp;
-        let untilTimestamp;
         let calculatedLimit;
         // Case 1: all three parameters provided
         if (sDate !== undefined && eDate !== undefined && limit !== undefined) {
@@ -2283,8 +2356,8 @@ class ClientExchange {
             if (eDate > whenTimestamp) {
                 throw new Error(`ClientExchange getRawCandles: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
             }
-            sinceTimestamp = sDate;
-            untilTimestamp = eDate;
+            // Align sDate down to interval boundary
+            sinceTimestamp = ALIGN_TO_INTERVAL_FN$1(sDate, step);
             calculatedLimit = limit;
         }
         // Case 2: sDate + eDate (no limit) - calculate limit from date range
@@ -2295,9 +2368,10 @@ class ClientExchange {
             if (eDate > whenTimestamp) {
                 throw new Error(`ClientExchange getRawCandles: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
             }
-            sinceTimestamp = sDate;
-            untilTimestamp = eDate;
-            calculatedLimit = Math.ceil((eDate - sDate) / (step * MS_PER_MINUTE$1));
+            // Align sDate down to interval boundary
+            sinceTimestamp = ALIGN_TO_INTERVAL_FN$1(sDate, step);
+            const alignedEDate = ALIGN_TO_INTERVAL_FN$1(eDate, step);
+            calculatedLimit = Math.ceil((alignedEDate - sinceTimestamp) / stepMs);
             if (calculatedLimit <= 0) {
                 throw new Error(`ClientExchange getRawCandles: calculated limit is ${calculatedLimit}, must be > 0`);
             }
@@ -2307,23 +2381,24 @@ class ClientExchange {
             if (eDate > whenTimestamp) {
                 throw new Error(`ClientExchange getRawCandles: eDate (${eDate}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
             }
-            untilTimestamp = eDate;
-            sinceTimestamp = eDate - limit * step * MS_PER_MINUTE$1;
+            // Align eDate down and calculate sinceTimestamp
+            const alignedEDate = ALIGN_TO_INTERVAL_FN$1(eDate, step);
+            sinceTimestamp = alignedEDate - limit * stepMs;
             calculatedLimit = limit;
         }
         // Case 4: sDate + limit (no eDate) - calculate eDate forward from sDate
         else if (sDate !== undefined && eDate === undefined && limit !== undefined) {
-            sinceTimestamp = sDate;
-            untilTimestamp = sDate + limit * step * MS_PER_MINUTE$1;
-            if (untilTimestamp > whenTimestamp) {
-                throw new Error(`ClientExchange getRawCandles: calculated endTimestamp (${untilTimestamp}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
+            // Align sDate down to interval boundary
+            sinceTimestamp = ALIGN_TO_INTERVAL_FN$1(sDate, step);
+            const endTimestamp = sinceTimestamp + limit * stepMs;
+            if (endTimestamp > whenTimestamp) {
+                throw new Error(`ClientExchange getRawCandles: calculated endTimestamp (${endTimestamp}) exceeds execution context when (${whenTimestamp}). Look-ahead bias protection.`);
             }
             calculatedLimit = limit;
         }
         // Case 5: Only limit - use execution.context.when as reference (backward like getCandles)
         else if (sDate === undefined && eDate === undefined && limit !== undefined) {
-            untilTimestamp = whenTimestamp;
-            sinceTimestamp = whenTimestamp - limit * step * MS_PER_MINUTE$1;
+            sinceTimestamp = alignedWhen - limit * stepMs;
             calculatedLimit = limit;
         }
         // Invalid: no parameters or only sDate or only eDate
@@ -2344,29 +2419,34 @@ class ClientExchange {
                 allData.push(...chunkData);
                 remaining -= chunkLimit;
                 if (remaining > 0) {
-                    currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE$1);
+                    currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
                 }
             }
         }
         else {
             allData = await GET_CANDLES_FN({ symbol, interval, limit: calculatedLimit }, since, this);
         }
-        // Filter candles to strictly match the requested range
-        // Only include candles that have fully CLOSED before untilTimestamp
-        const stepMs = step * MS_PER_MINUTE$1;
-        const filteredData = allData.filter((candle) => candle.timestamp > sinceTimestamp &&
-            candle.timestamp + stepMs < untilTimestamp);
         // 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`;
+        const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
+        if (allData.length !== uniqueData.length) {
+            const msg = `ClientExchange getRawCandles: Removed ${allData.length - uniqueData.length} duplicate candles by timestamp`;
             this.params.logger.warn(msg);
             console.warn(msg);
         }
-        if (uniqueData.length < calculatedLimit) {
-            const msg = `ClientExchange getRawCandles: Expected ${calculatedLimit} candles, got ${uniqueData.length}`;
-            this.params.logger.warn(msg);
-            console.warn(msg);
+        // Validate adapter returned data
+        if (uniqueData.length === 0) {
+            throw new Error(`ClientExchange getRawCandles: adapter returned empty array. ` +
+                `Expected ${calculatedLimit} candles starting from openTime=${sinceTimestamp}.`);
+        }
+        if (uniqueData[0].timestamp !== sinceTimestamp) {
+            throw new Error(`ClientExchange getRawCandles: first candle timestamp mismatch. ` +
+                `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
+                `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
+        }
+        if (uniqueData.length !== calculatedLimit) {
+            throw new Error(`ClientExchange getRawCandles: candle count mismatch. ` +
+                `Expected ${calculatedLimit} candles, got ${uniqueData.length}. ` +
+                `Adapter must return exact number of candles requested.`);
         }
         await CALL_CANDLE_DATA_CALLBACKS_FN(this, symbol, interval, since, calculatedLimit, uniqueData);
         return uniqueData;
@@ -4924,6 +5004,68 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
             const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "user");
             return { activated: false, cancelled: true, activationIndex: i, result };
         }
+        // КРИТИЧНО: Проверяем был ли сигнал активирован пользователем через activateScheduled()
+        // Обрабатываем inline (как в tick()) с риск-проверкой по averagePrice
+        if (self._activatedSignal) {
+            const activatedSignal = self._activatedSignal;
+            self._activatedSignal = null;
+            // Check if strategy was stopped
+            if (self._isStopped) {
+                self.params.logger.info("ClientStrategy backtest user-activated signal cancelled (stopped)", {
+                    symbol: self.params.execution.context.symbol,
+                    signalId: activatedSignal.id,
+                });
+                await self.setScheduledSignal(null);
+                return { activated: false, cancelled: false, activationIndex: i, result: null };
+            }
+            // Риск-проверка по averagePrice (симметрия с LIVE tick())
+            if (await not(CALL_RISK_CHECK_SIGNAL_FN(self, self.params.execution.context.symbol, activatedSignal, averagePrice, candle.timestamp, self.params.execution.context.backtest))) {
+                self.params.logger.info("ClientStrategy backtest user-activated signal rejected by risk", {
+                    symbol: self.params.execution.context.symbol,
+                    signalId: activatedSignal.id,
+                });
+                await self.setScheduledSignal(null);
+                return { activated: false, cancelled: false, activationIndex: i, result: null };
+            }
+            await self.setScheduledSignal(null);
+            const pendingSignal = {
+                ...activatedSignal,
+                pendingAt: candle.timestamp,
+                _isScheduled: false,
+            };
+            await self.setPendingSignal(pendingSignal);
+            await CALL_RISK_ADD_SIGNAL_FN(self, self.params.execution.context.symbol, pendingSignal, candle.timestamp, self.params.execution.context.backtest);
+            // Emit commit AFTER successful risk check
+            const publicSignalForCommit = TO_PUBLIC_SIGNAL(pendingSignal);
+            await CALL_COMMIT_FN(self, {
+                action: "activate-scheduled",
+                symbol: self.params.execution.context.symbol,
+                strategyName: self.params.strategyName,
+                exchangeName: self.params.exchangeName,
+                frameName: self.params.frameName,
+                signalId: activatedSignal.id,
+                backtest: self.params.execution.context.backtest,
+                activateId: activatedSignal.activateId,
+                timestamp: candle.timestamp,
+                currentPrice: averagePrice,
+                position: publicSignalForCommit.position,
+                priceOpen: publicSignalForCommit.priceOpen,
+                priceTakeProfit: publicSignalForCommit.priceTakeProfit,
+                priceStopLoss: publicSignalForCommit.priceStopLoss,
+                originalPriceTakeProfit: publicSignalForCommit.originalPriceTakeProfit,
+                originalPriceStopLoss: publicSignalForCommit.originalPriceStopLoss,
+                scheduledAt: publicSignalForCommit.scheduledAt,
+                pendingAt: publicSignalForCommit.pendingAt,
+            });
+            await CALL_OPEN_CALLBACKS_FN(self, self.params.execution.context.symbol, pendingSignal, pendingSignal.priceOpen, candle.timestamp, self.params.execution.context.backtest);
+            await CALL_BACKTEST_SCHEDULE_OPEN_FN(self, self.params.execution.context.symbol, pendingSignal, candle.timestamp, self.params.execution.context.backtest);
+            return {
+                activated: true,
+                cancelled: false,
+                activationIndex: i,
+                result: null,
+            };
+        }
         // КРИТИЧНО: Проверяем timeout ПЕРЕД проверкой цены
         const elapsedTime = candle.timestamp - scheduled.scheduledAt;
         if (elapsedTime >= maxTimeToWait) {
@@ -5146,6 +5288,7 @@ class ClientStrategy {
         this._scheduledSignal = null;
         this._cancelledSignal = null;
         this._closedSignal = null;
+        this._activatedSignal = null;
         /** Queue for commit events to be processed in tick()/backtest() with proper timestamp */
         this._commitQueue = [];
         /**
@@ -5183,6 +5326,16 @@ class ClientStrategy {
         this.params.logger.debug("ClientStrategy setPendingSignal", {
             pendingSignal,
         });
+        // КРИТИЧНО: Очищаем флаг закрытия при любом изменении pending signal
+        // - при null: сигнал закрыт по TP/SL/timeout, флаг больше не нужен
+        // - при новом сигнале: флаг от предыдущего сигнала не должен влиять на новый
+        this._closedSignal = null;
+        // ЗАЩИТА ИНВАРИАНТА: При установке нового pending сигнала очищаем scheduled
+        // Не может быть одновременно pending И scheduled (взаимоисключающие состояния)
+        // При null: scheduled может существовать (новый сигнал после закрытия позиции)
+        if (pendingSignal !== null) {
+            this._scheduledSignal = null;
+        }
         this._pendingSignal = pendingSignal;
         // КРИТИЧНО: Всегда вызываем коллбек onWrite для тестирования persist storage
         // даже в backtest режиме, чтобы тесты могли перехватывать вызовы через mock adapter
@@ -5208,6 +5361,11 @@ class ClientStrategy {
         this.params.logger.debug("ClientStrategy setScheduledSignal", {
             scheduledSignal,
         });
+        // КРИТИЧНО: Очищаем флаги отмены и активации при любом изменении scheduled signal
+        // - при null: сигнал отменен/активирован по timeout/SL/user, флаги больше не нужны
+        // - при новом сигнале: флаги от предыдущего сигнала не должны влиять на новый
+        this._cancelledSignal = null;
+        this._activatedSignal = null;
         this._scheduledSignal = scheduledSignal;
         if (this.params.execution.context.backtest) {
             return;
@@ -5397,12 +5555,8 @@ class ClientStrategy {
         const currentTime = this.params.execution.context.when.getTime();
         // Process queued commit events with proper timestamp
         await PROCESS_COMMIT_QUEUE_FN(this, currentTime);
-        // Early return if strategy was stopped
-        if (this._isStopped) {
-            const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
-            return await RETURN_IDLE_FN(this, currentPrice);
-        }
         // Check if scheduled signal was cancelled - emit cancelled event once
+        // NOTE: No _isStopped check here - cancellation must work for graceful shutdown
         if (this._cancelledSignal) {
             const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
             const cancelledSignal = this._cancelledSignal;
@@ -5411,6 +5565,18 @@ class ClientStrategy {
                 symbol: this.params.execution.context.symbol,
                 signalId: cancelledSignal.id,
             });
+            // Emit commit with correct timestamp from tick context
+            await CALL_COMMIT_FN(this, {
+                action: "cancel-scheduled",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: cancelledSignal.id,
+                backtest: this.params.execution.context.backtest,
+                cancelId: cancelledSignal.cancelId,
+                timestamp: currentTime,
+            });
             // Call onCancel callback
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, currentTime, this.params.execution.context.backtest);
             const result = {
@@ -5439,6 +5605,18 @@ class ClientStrategy {
                 symbol: this.params.execution.context.symbol,
                 signalId: closedSignal.id,
             });
+            // Emit commit with correct timestamp from tick context
+            await CALL_COMMIT_FN(this, {
+                action: "close-pending",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: closedSignal.id,
+                backtest: this.params.execution.context.backtest,
+                closeId: closedSignal.closeId,
+                timestamp: currentTime,
+            });
             // Call onClose callback
             await CALL_CLOSE_CALLBACKS_FN(this, this.params.execution.context.symbol, closedSignal, currentPrice, currentTime, this.params.execution.context.backtest);
             // КРИТИЧНО: Очищаем состояние ClientPartial при закрытии позиции
@@ -5465,6 +5643,78 @@ class ClientStrategy {
             await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, result, currentTime, this.params.execution.context.backtest);
             return result;
         }
+        // Check if scheduled signal was activated - emit opened event once
+        if (this._activatedSignal) {
+            const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+            const activatedSignal = this._activatedSignal;
+            this._activatedSignal = null; // Clear after emitting
+            this.params.logger.info("ClientStrategy tick: scheduled signal was activated", {
+                symbol: this.params.execution.context.symbol,
+                signalId: activatedSignal.id,
+            });
+            // Check if strategy was stopped (symmetry with backtest PROCESS_SCHEDULED_SIGNAL_CANDLES_FN)
+            if (this._isStopped) {
+                this.params.logger.info("ClientStrategy tick: user-activated signal cancelled (stopped)", {
+                    symbol: this.params.execution.context.symbol,
+                    signalId: activatedSignal.id,
+                });
+                await this.setScheduledSignal(null);
+                return await RETURN_IDLE_FN(this, currentPrice);
+            }
+            // Check risk before activation
+            if (await not(CALL_RISK_CHECK_SIGNAL_FN(this, this.params.execution.context.symbol, activatedSignal, currentPrice, currentTime, this.params.execution.context.backtest))) {
+                this.params.logger.info("ClientStrategy tick: activated signal rejected by risk", {
+                    symbol: this.params.execution.context.symbol,
+                    signalId: activatedSignal.id,
+                });
+                return await RETURN_IDLE_FN(this, currentPrice);
+            }
+            // КРИТИЧЕСКИ ВАЖНО: обновляем pendingAt при активации
+            const pendingSignal = {
+                ...activatedSignal,
+                pendingAt: currentTime,
+                _isScheduled: false,
+            };
+            await this.setPendingSignal(pendingSignal);
+            await CALL_RISK_ADD_SIGNAL_FN(this, this.params.execution.context.symbol, pendingSignal, currentTime, this.params.execution.context.backtest);
+            // Emit commit AFTER successful risk check
+            const publicSignalForCommit = TO_PUBLIC_SIGNAL(pendingSignal);
+            await CALL_COMMIT_FN(this, {
+                action: "activate-scheduled",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: activatedSignal.id,
+                backtest: this.params.execution.context.backtest,
+                activateId: activatedSignal.activateId,
+                timestamp: currentTime,
+                currentPrice,
+                position: publicSignalForCommit.position,
+                priceOpen: publicSignalForCommit.priceOpen,
+                priceTakeProfit: publicSignalForCommit.priceTakeProfit,
+                priceStopLoss: publicSignalForCommit.priceStopLoss,
+                originalPriceTakeProfit: publicSignalForCommit.originalPriceTakeProfit,
+                originalPriceStopLoss: publicSignalForCommit.originalPriceStopLoss,
+                scheduledAt: publicSignalForCommit.scheduledAt,
+                pendingAt: publicSignalForCommit.pendingAt,
+            });
+            // Call onOpen callback
+            await CALL_OPEN_CALLBACKS_FN(this, this.params.execution.context.symbol, pendingSignal, currentPrice, currentTime, this.params.execution.context.backtest);
+            const result = {
+                action: "opened",
+                signal: TO_PUBLIC_SIGNAL(pendingSignal),
+                strategyName: this.params.method.context.strategyName,
+                exchangeName: this.params.method.context.exchangeName,
+                frameName: this.params.method.context.frameName,
+                symbol: this.params.execution.context.symbol,
+                currentPrice,
+                backtest: this.params.execution.context.backtest,
+                createdAt: currentTime,
+            };
+            await CALL_TICK_CALLBACKS_FN(this, this.params.execution.context.symbol, result, currentTime, this.params.execution.context.backtest);
+            return result;
+        }
         // Monitor scheduled signal
         if (this._scheduledSignal && !this._pendingSignal) {
             const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
@@ -5488,7 +5738,12 @@ class ClientStrategy {
             return await RETURN_SCHEDULED_SIGNAL_ACTIVE_FN(this, this._scheduledSignal, currentPrice);
         }
         // Generate new signal if none exists
+        // NOTE: _isStopped blocks NEW signal generation but allows existing positions to continue
         if (!this._pendingSignal && !this._scheduledSignal) {
+            if (this._isStopped) {
+                const currentPrice = await this.params.exchange.getAveragePrice(this.params.execution.context.symbol);
+                return await RETURN_IDLE_FN(this, currentPrice);
+            }
             const signal = await GET_SIGNAL_FN(this);
             if (signal) {
                 if (signal._isScheduled === true) {
@@ -5562,6 +5817,18 @@ class ClientStrategy {
             const cancelledSignal = this._cancelledSignal;
             this._cancelledSignal = null; // Clear after using
             const closeTimestamp = this.params.execution.context.when.getTime();
+            // Emit commit with correct timestamp from backtest context
+            await CALL_COMMIT_FN(this, {
+                action: "cancel-scheduled",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: cancelledSignal.id,
+                backtest: true,
+                cancelId: cancelledSignal.cancelId,
+                timestamp: closeTimestamp,
+            });
             await CALL_CANCEL_CALLBACKS_FN(this, this.params.execution.context.symbol, cancelledSignal, currentPrice, closeTimestamp, this.params.execution.context.backtest);
             const cancelledResult = {
                 action: "cancelled",
@@ -5587,6 +5854,18 @@ class ClientStrategy {
             const closedSignal = this._closedSignal;
             this._closedSignal = null; // Clear after using
             const closeTimestamp = this.params.execution.context.when.getTime();
+            // Emit commit with correct timestamp from backtest context
+            await CALL_COMMIT_FN(this, {
+                action: "close-pending",
+                symbol: this.params.execution.context.symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                signalId: closedSignal.id,
+                backtest: true,
+                closeId: closedSignal.closeId,
+                timestamp: closeTimestamp,
+            });
             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);
@@ -5747,8 +6026,18 @@ class ClientStrategy {
             symbol,
             hasPendingSignal: this._pendingSignal !== null,
             hasScheduledSignal: this._scheduledSignal !== null,
+            hasActivatedSignal: this._activatedSignal !== null,
+            hasCancelledSignal: this._cancelledSignal !== null,
+            hasClosedSignal: this._closedSignal !== null,
         });
         this._isStopped = true;
+        // Clear pending flags to start from clean state
+        // NOTE: _isStopped blocks NEW position opening, but allows:
+        // - cancelScheduled() / closePending() for graceful shutdown
+        // - Monitoring existing _pendingSignal until TP/SL/timeout
+        this._activatedSignal = null;
+        this._cancelledSignal = null;
+        this._closedSignal = null;
         // Clear scheduled signal if exists
         if (!this._scheduledSignal) {
             return;
@@ -5786,8 +6075,9 @@ class ClientStrategy {
             hasScheduledSignal: this._scheduledSignal !== null,
             cancelId,
         });
-        // Save cancelled signal for next tick to emit cancelled event
-        const hadScheduledSignal = this._scheduledSignal !== null;
+        // NOTE: No _isStopped check - cancellation must work for graceful shutdown
+        // (cancelling scheduled signal is not opening new position)
+        // Save cancelled signal for next tick/backtest to emit cancelled event with correct timestamp
         if (this._scheduledSignal) {
             this._cancelledSignal = Object.assign({}, this._scheduledSignal, {
                 cancelId,
@@ -5795,37 +6085,60 @@ class ClientStrategy {
             this._scheduledSignal = null;
         }
         if (backtest) {
-            // Emit commit event only if signal was actually cancelled
-            if (hadScheduledSignal) {
-                await CALL_COMMIT_FN(this, {
-                    action: "cancel-scheduled",
-                    symbol,
-                    strategyName: this.params.strategyName,
-                    exchangeName: this.params.exchangeName,
-                    frameName: this.params.frameName,
-                    signalId: this._cancelledSignal.id,
-                    backtest,
-                    cancelId,
-                    timestamp: this.params.execution.context.when.getTime(),
-                });
-            }
+            // Commit will be emitted in backtest() with correct candle timestamp
             return;
         }
         await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
-        // Emit commit event only if signal was actually cancelled
-        if (hadScheduledSignal) {
-            await CALL_COMMIT_FN(this, {
-                action: "cancel-scheduled",
+        // Commit will be emitted in tick() with correct currentTime
+    }
+    /**
+     * Activates the scheduled signal without waiting for price to reach priceOpen.
+     *
+     * Forces immediate activation of the scheduled signal at the current price.
+     * Does NOT affect active pending signals or strategy operation.
+     * Does NOT set stop flag - strategy can continue generating new signals.
+     *
+     * Use case: User-initiated early activation of a scheduled entry.
+     *
+     * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+     * @param backtest - Whether running in backtest mode
+     * @param activateId - Optional identifier for this activation operation
+     * @returns Promise that resolves when scheduled signal is activated
+     *
+     * @example
+     * ```typescript
+     * // Activate scheduled signal without waiting for priceOpen
+     * await strategy.activateScheduled("BTCUSDT", false, "user-activate-123");
+     * // Scheduled signal becomes pending signal immediately
+     * ```
+     */
+    async activateScheduled(symbol, backtest, activateId) {
+        this.params.logger.debug("ClientStrategy activateScheduled", {
+            symbol,
+            hasScheduledSignal: this._scheduledSignal !== null,
+            activateId,
+        });
+        // Block activation if strategy stopped - activation = opening NEW position
+        // (unlike cancelScheduled/closePending which handle existing signals for graceful shutdown)
+        if (this._isStopped) {
+            this.params.logger.debug("ClientStrategy activateScheduled: strategy stopped, skipping", {
                 symbol,
-                strategyName: this.params.strategyName,
-                exchangeName: this.params.exchangeName,
-                frameName: this.params.frameName,
-                signalId: this._cancelledSignal.id,
-                backtest,
-                cancelId,
-                timestamp: this.params.execution.context.when.getTime(),
             });
+            return;
+        }
+        // Save activated signal for next tick to emit opened event
+        if (this._scheduledSignal) {
+            this._activatedSignal = Object.assign({}, this._scheduledSignal, {
+                activateId,
+            });
+            this._scheduledSignal = null;
+        }
+        if (backtest) {
+            // Commit will be emitted AFTER successful risk check in PROCESS_SCHEDULED_SIGNAL_CANDLES_FN
+            return;
         }
+        await PersistScheduleAdapter.writeScheduleData(this._scheduledSignal, symbol, this.params.method.context.strategyName, this.params.method.context.exchangeName);
+        // Commit will be emitted AFTER successful risk check in tick()
     }
     /**
      * Closes the pending signal without stopping the strategy.
@@ -5854,8 +6167,8 @@ class ClientStrategy {
             hasPendingSignal: this._pendingSignal !== null,
             closeId,
         });
-        // Save closed signal for next tick to emit closed event
-        const hadPendingSignal = this._pendingSignal !== null;
+        // NOTE: No _isStopped check - closing position must work for graceful shutdown
+        // Save closed signal for next tick/backtest to emit closed event with correct timestamp
         if (this._pendingSignal) {
             this._closedSignal = Object.assign({}, this._pendingSignal, {
                 closeId,
@@ -5863,37 +6176,11 @@ class ClientStrategy {
             this._pendingSignal = null;
         }
         if (backtest) {
-            // Emit commit event only if signal was actually closed
-            if (hadPendingSignal) {
-                await CALL_COMMIT_FN(this, {
-                    action: "close-pending",
-                    symbol,
-                    strategyName: this.params.strategyName,
-                    exchangeName: this.params.exchangeName,
-                    frameName: this.params.frameName,
-                    signalId: this._closedSignal.id,
-                    backtest,
-                    closeId,
-                    timestamp: this.params.execution.context.when.getTime(),
-                });
-            }
+            // Commit will be emitted in backtest() with correct candle timestamp
             return;
         }
         await PersistSignalAdapter.writeSignalData(this._pendingSignal, symbol, this.params.strategyName, this.params.exchangeName);
-        // Emit commit event only if signal was actually closed
-        if (hadPendingSignal) {
-            await CALL_COMMIT_FN(this, {
-                action: "close-pending",
-                symbol,
-                strategyName: this.params.strategyName,
-                exchangeName: this.params.exchangeName,
-                frameName: this.params.frameName,
-                signalId: this._closedSignal.id,
-                backtest,
-                closeId,
-                timestamp: this.params.execution.context.when.getTime(),
-            });
-        }
+        // Commit will be emitted in tick() with correct currentTime
     }
     /**
      * Executes partial close at profit level (moving toward TP).
@@ -7732,6 +8019,39 @@ class StrategyConnectionService {
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             return await strategy.breakeven(symbol, currentPrice, backtest);
         };
+        /**
+         * Activates a scheduled signal early without waiting for price to reach priceOpen.
+         *
+         * Delegates to ClientStrategy.activateScheduled() which sets _activatedSignal flag.
+         * The actual activation happens on next tick() when strategy detects the flag.
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @param activateId - Optional identifier for the activation reason
+         * @returns Promise that resolves when activation flag is set
+         *
+         * @example
+         * ```typescript
+         * // Activate scheduled signal early
+         * await strategyConnectionService.activateScheduled(
+         *   false,
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" },
+         *   "manual-activation"
+         * );
+         * ```
+         */
+        this.activateScheduled = async (backtest, symbol, context, activateId) => {
+            this.loggerService.log("strategyConnectionService activateScheduled", {
+                symbol,
+                context,
+                backtest,
+                activateId,
+            });
+            const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
+            return await strategy.activateScheduled(symbol, backtest, activateId);
+        };
     }
 }
 
@@ -11044,6 +11364,39 @@ class StrategyCoreService {
             await this.validate(context);
             return await this.strategyConnectionService.breakeven(backtest, symbol, currentPrice, context);
         };
+        /**
+         * Activates a scheduled signal early without waiting for price to reach priceOpen.
+         *
+         * Validates strategy existence and delegates to connection service
+         * to set the activation flag. The actual activation happens on next tick().
+         *
+         * @param backtest - Whether running in backtest mode
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, frameName
+         * @param activateId - Optional identifier for the activation reason
+         * @returns Promise that resolves when activation flag is set
+         *
+         * @example
+         * ```typescript
+         * // Activate scheduled signal early
+         * await strategyCoreService.activateScheduled(
+         *   false,
+         *   "BTCUSDT",
+         *   { strategyName: "my-strategy", exchangeName: "binance", frameName: "" },
+         *   "manual-activation"
+         * );
+         * ```
+         */
+        this.activateScheduled = async (backtest, symbol, context, activateId) => {
+            this.loggerService.log("strategyCoreService activateScheduled", {
+                symbol,
+                context,
+                backtest,
+                activateId,
+            });
+            await this.validate(context);
+            return await this.strategyConnectionService.activateScheduled(backtest, symbol, context, activateId);
+        };
     }
 }
 
@@ -12323,13 +12676,8 @@ class WalkerSchemaService {
     }
 }
 
-/**
- * Компенсация для exclusive boundaries при фильтрации свечей.
- * ClientExchange.getNextCandles использует фильтр:
- *   timestamp > since && timestamp + stepMs < endTime
- * который исключает первую и последнюю свечи из запрошенного диапазона.
- */
-const CANDLE_EXCLUSIVE_BOUNDARY_OFFSET = 2;
+const ACTIVE_CANDLE_INCLUDED = 1;
+const SCHEDULE_ACTIVATION_CANDLE_SKIP = 1;
 /**
  * Private service for backtest orchestration using async generators.
  *
@@ -12453,9 +12801,9 @@ class BacktestLogicPrivateService {
                 // - CC_SCHEDULE_AWAIT_MINUTES для ожидания активации
                 // - minuteEstimatedTime для работы сигнала ПОСЛЕ активации
                 // - +1 потому что when включается как первая свеча
-                const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
+                const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - ACTIVE_CANDLE_INCLUDED;
                 const bufferStartTime = new Date(when.getTime() - bufferMinutes * 60 * 1000);
-                const candlesNeeded = bufferMinutes + GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES + signal.minuteEstimatedTime + 1;
+                const candlesNeeded = bufferMinutes + GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES + signal.minuteEstimatedTime + SCHEDULE_ACTIVATION_CANDLE_SKIP;
                 let candles;
                 try {
                     candles = await this.exchangeCoreService.getNextCandles(symbol, "1m", candlesNeeded, bufferStartTime, true);
@@ -12593,9 +12941,9 @@ class BacktestLogicPrivateService {
                 // КРИТИЧНО: Получаем свечи включая буфер для VWAP
                 // Сдвигаем начало назад на CC_AVG_PRICE_CANDLES_COUNT-1 минут для буфера VWAP
                 // Запрашиваем minuteEstimatedTime + буфер свечей одним запросом
-                const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - 1;
+                const bufferMinutes = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT - ACTIVE_CANDLE_INCLUDED;
                 const bufferStartTime = new Date(when.getTime() - bufferMinutes * 60 * 1000);
-                const totalCandles = signal.minuteEstimatedTime + GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT + CANDLE_EXCLUSIVE_BOUNDARY_OFFSET;
+                const totalCandles = signal.minuteEstimatedTime + GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
                 let candles;
                 try {
                     candles = await this.exchangeCoreService.getNextCandles(symbol, "1m", totalCandles, bufferStartTime, true);
@@ -24283,6 +24631,67 @@ class StrategyReportService {
                 walkerName: "",
             });
         };
+        /**
+         * Logs an activate-scheduled event when a scheduled signal is activated early.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param currentPrice - Current market price at time of activation
+         * @param isBacktest - Whether this is a backtest or live trading event
+         * @param context - Strategy context with strategyName, exchangeName, frameName
+         * @param timestamp - Timestamp from StrategyCommitContract (execution context time)
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Entry price for the position
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         * @param activateId - Optional identifier for the activation reason
+         */
+        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, activateId) => {
+            this.loggerService.log("strategyReportService activateScheduled", {
+                symbol,
+                currentPrice,
+                isBacktest,
+                activateId,
+            });
+            if (!this.subscribe.hasValue()) {
+                return;
+            }
+            const scheduledRow = await this.strategyCoreService.getScheduledSignal(isBacktest, symbol, {
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+            });
+            if (!scheduledRow) {
+                return;
+            }
+            const createdAt = new Date(timestamp).toISOString();
+            await Report.writeData("strategy", {
+                action: "activate-scheduled",
+                activateId,
+                currentPrice,
+                symbol,
+                timestamp,
+                createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
+            }, {
+                signalId: scheduledRow.id,
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+                strategyName: context.strategyName,
+                symbol,
+                walkerName: "",
+            });
+        };
         /**
          * Initializes the service for event logging.
          *
@@ -24342,7 +24751,14 @@ class StrategyReportService {
                 frameName: event.frameName,
                 strategyName: event.strategyName,
             }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
-            const disposeFn = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven());
+            const unActivateScheduled = strategyCommitSubject
+                .filter(({ action }) => action === "activate-scheduled")
+                .connect(async (event) => await this.activateScheduled(event.symbol, event.currentPrice, event.backtest, {
+                exchangeName: event.exchangeName,
+                frameName: event.frameName,
+                strategyName: event.strategyName,
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.activateId));
+            const disposeFn = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled());
             return () => {
                 disposeFn();
                 this.subscribe.clear();
@@ -24473,6 +24889,7 @@ class ReportStorage {
                 trailingStopCount: 0,
                 trailingTakeCount: 0,
                 breakevenCount: 0,
+                activateScheduledCount: 0,
             };
         }
         return {
@@ -24485,6 +24902,7 @@ class ReportStorage {
             trailingStopCount: this._eventList.filter(e => e.action === "trailing-stop").length,
             trailingTakeCount: this._eventList.filter(e => e.action === "trailing-take").length,
             breakevenCount: this._eventList.filter(e => e.action === "breakeven").length,
+            activateScheduledCount: this._eventList.filter(e => e.action === "activate-scheduled").length,
         };
     }
     /**
@@ -24533,6 +24951,7 @@ class ReportStorage {
             `- Trailing stop: ${stats.trailingStopCount}`,
             `- Trailing take: ${stats.trailingTakeCount}`,
             `- Breakeven: ${stats.breakevenCount}`,
+            `- Activate scheduled: ${stats.activateScheduledCount}`,
         ].join("\n");
     }
     /**
@@ -24999,6 +25418,66 @@ class StrategyMarkdownService {
                 pendingAt,
             });
         };
+        /**
+         * Records an activate-scheduled event when a scheduled signal is activated early.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param currentPrice - Current market price at time of activation
+         * @param isBacktest - Whether this is a backtest or live trading event
+         * @param context - Strategy context with strategyName, exchangeName, frameName
+         * @param timestamp - Timestamp from StrategyCommitContract (execution context time)
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Entry price for the position
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         * @param activateId - Optional identifier for the activation reason
+         */
+        this.activateScheduled = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt, activateId) => {
+            this.loggerService.log("strategyMarkdownService activateScheduled", {
+                symbol,
+                currentPrice,
+                isBacktest,
+                activateId,
+            });
+            if (!this.subscribe.hasValue()) {
+                return;
+            }
+            const scheduledRow = await this.strategyCoreService.getScheduledSignal(isBacktest, symbol, {
+                exchangeName: context.exchangeName,
+                strategyName: context.strategyName,
+                frameName: context.frameName,
+            });
+            if (!scheduledRow) {
+                return;
+            }
+            const createdAt = new Date(timestamp).toISOString();
+            const storage = this.getStorage(symbol, context.strategyName, context.exchangeName, context.frameName, isBacktest);
+            storage.addEvent({
+                timestamp,
+                symbol,
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: context.frameName,
+                signalId: scheduledRow.id,
+                action: "activate-scheduled",
+                activateId,
+                currentPrice,
+                createdAt,
+                backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
+            });
+        };
         /**
          * Retrieves aggregated statistics from accumulated strategy events.
          *
@@ -25172,7 +25651,14 @@ class StrategyMarkdownService {
                 frameName: event.frameName,
                 strategyName: event.strategyName,
             }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
-            const disposeFn = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven());
+            const unActivateScheduled = strategyCommitSubject
+                .filter(({ action }) => action === "activate-scheduled")
+                .connect(async (event) => await this.activateScheduled(event.symbol, event.currentPrice, event.backtest, {
+                exchangeName: event.exchangeName,
+                frameName: event.frameName,
+                strategyName: event.strategyName,
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt, event.activateId));
+            const disposeFn = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled());
             return () => {
                 disposeFn();
                 this.subscribe.clear();
@@ -26098,6 +26584,7 @@ const PARTIAL_LOSS_METHOD_NAME = "strategy.commitPartialLoss";
 const TRAILING_STOP_METHOD_NAME = "strategy.commitTrailingStop";
 const TRAILING_PROFIT_METHOD_NAME = "strategy.commitTrailingTake";
 const BREAKEVEN_METHOD_NAME = "strategy.commitBreakeven";
+const ACTIVATE_SCHEDULED_METHOD_NAME = "strategy.commitActivateScheduled";
 /**
  * Cancels the scheduled signal without stopping the strategy.
  *
@@ -26415,6 +26902,41 @@ async function commitBreakeven(symbol) {
     const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
     return await bt.strategyCoreService.breakeven(isBacktest, symbol, currentPrice, { exchangeName, frameName, strategyName });
 }
+/**
+ * Activates a scheduled signal early without waiting for price to reach priceOpen.
+ *
+ * Sets the activation flag on the scheduled signal. The actual activation
+ * happens on the next tick() when strategy detects the flag.
+ *
+ * Automatically detects backtest/live mode from execution context.
+ *
+ * @param symbol - Trading pair symbol
+ * @param activateId - Optional activation ID for tracking user-initiated activations
+ * @returns Promise that resolves when activation flag is set
+ *
+ * @example
+ * ```typescript
+ * import { commitActivateScheduled } from "backtest-kit";
+ *
+ * // Activate scheduled signal early with custom ID
+ * await commitActivateScheduled("BTCUSDT", "manual-activate-001");
+ * ```
+ */
+async function commitActivateScheduled(symbol, activateId) {
+    bt.loggerService.info(ACTIVATE_SCHEDULED_METHOD_NAME, {
+        symbol,
+        activateId,
+    });
+    if (!ExecutionContextService.hasContext()) {
+        throw new Error("commitActivateScheduled requires an execution context");
+    }
+    if (!MethodContextService.hasContext()) {
+        throw new Error("commitActivateScheduled requires a method context");
+    }
+    const { backtest: isBacktest } = bt.executionContextService.context;
+    const { exchangeName, frameName, strategyName } = bt.methodContextService.context;
+    await bt.strategyCoreService.activateScheduled(isBacktest, symbol, { exchangeName, frameName, strategyName }, activateId);
+}
 
 const STOP_STRATEGY_METHOD_NAME = "control.stopStrategy";
 /**
@@ -28585,6 +29107,7 @@ const BACKTEST_METHOD_NAME_PARTIAL_PROFIT = "BacktestUtils.commitPartialProfit";
 const BACKTEST_METHOD_NAME_PARTIAL_LOSS = "BacktestUtils.commitPartialLoss";
 const BACKTEST_METHOD_NAME_TRAILING_STOP = "BacktestUtils.commitTrailingStop";
 const BACKTEST_METHOD_NAME_TRAILING_PROFIT = "BacktestUtils.commitTrailingTake";
+const BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED = "Backtest.commitActivateScheduled";
 const BACKTEST_METHOD_NAME_GET_DATA = "BacktestUtils.getData";
 /**
  * Internal task function that runs backtest and handles completion.
@@ -29441,6 +29964,46 @@ class BacktestUtils {
             }
             return await bt.strategyCoreService.breakeven(true, symbol, currentPrice, context);
         };
+        /**
+         * Activates a scheduled signal early without waiting for price to reach priceOpen.
+         *
+         * Sets the activation flag on the scheduled signal. The actual activation
+         * happens on the next tick() when strategy detects the flag.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName, exchangeName, and frameName
+         * @param activateId - Optional activation ID for tracking user-initiated activations
+         * @returns Promise that resolves when activation flag is set
+         *
+         * @example
+         * ```typescript
+         * // Activate scheduled signal early with custom ID
+         * await Backtest.commitActivateScheduled("BTCUSDT", {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance",
+         *   frameName: "1h"
+         * }, "manual-activate-001");
+         * ```
+         */
+        this.commitActivateScheduled = async (symbol, context, activateId) => {
+            bt.loggerService.info(BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED, {
+                symbol,
+                context,
+                activateId,
+            });
+            bt.strategyValidationService.validate(context.strategyName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED);
+            bt.exchangeValidationService.validate(context.exchangeName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName &&
+                    bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED);
+                riskList &&
+                    riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED));
+                actions &&
+                    actions.forEach((actionName) => bt.actionValidationService.validate(actionName, BACKTEST_METHOD_NAME_ACTIVATE_SCHEDULED));
+            }
+            await bt.strategyCoreService.activateScheduled(true, symbol, context, activateId);
+        };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
          *
@@ -29616,6 +30179,7 @@ const LIVE_METHOD_NAME_PARTIAL_PROFIT = "LiveUtils.commitPartialProfit";
 const LIVE_METHOD_NAME_PARTIAL_LOSS = "LiveUtils.commitPartialLoss";
 const LIVE_METHOD_NAME_TRAILING_STOP = "LiveUtils.commitTrailingStop";
 const LIVE_METHOD_NAME_TRAILING_PROFIT = "LiveUtils.commitTrailingTake";
+const LIVE_METHOD_NAME_ACTIVATE_SCHEDULED = "Live.commitActivateScheduled";
 /**
  * Internal task function that runs live trading and handles completion.
  * Consumes live trading results and updates instance state flags.
@@ -30440,6 +31004,46 @@ class LiveUtils {
                 frameName: "",
             });
         };
+        /**
+         * Activates a scheduled signal early without waiting for price to reach priceOpen.
+         *
+         * Sets the activation flag on the scheduled signal. The actual activation
+         * happens on the next tick() when strategy detects the flag.
+         *
+         * @param symbol - Trading pair symbol
+         * @param context - Execution context with strategyName and exchangeName
+         * @param activateId - Optional activation ID for tracking user-initiated activations
+         * @returns Promise that resolves when activation flag is set
+         *
+         * @example
+         * ```typescript
+         * // Activate scheduled signal early with custom ID
+         * await Live.commitActivateScheduled("BTCUSDT", {
+         *   strategyName: "my-strategy",
+         *   exchangeName: "binance"
+         * }, "manual-activate-001");
+         * ```
+         */
+        this.commitActivateScheduled = async (symbol, context, activateId) => {
+            bt.loggerService.info(LIVE_METHOD_NAME_ACTIVATE_SCHEDULED, {
+                symbol,
+                context,
+                activateId,
+            });
+            bt.strategyValidationService.validate(context.strategyName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED);
+            bt.exchangeValidationService.validate(context.exchangeName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED);
+            {
+                const { riskName, riskList, actions } = bt.strategySchemaService.get(context.strategyName);
+                riskName && bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED);
+                riskList && riskList.forEach((riskName) => bt.riskValidationService.validate(riskName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED));
+                actions && actions.forEach((actionName) => bt.actionValidationService.validate(actionName, LIVE_METHOD_NAME_ACTIVATE_SCHEDULED));
+            }
+            await bt.strategyCoreService.activateScheduled(false, symbol, {
+                strategyName: context.strategyName,
+                exchangeName: context.exchangeName,
+                frameName: "",
+            }, activateId);
+        };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
          *
@@ -33089,6 +33693,27 @@ const INTERVAL_MINUTES$1 = {
     "6h": 360,
     "8h": 480,
 };
+/**
+ * Aligns timestamp down to the nearest interval boundary.
+ * For example, for 15m interval: 00:17 -> 00:15, 00:44 -> 00:30
+ *
+ * Candle timestamp convention:
+ * - Candle timestamp = openTime (when candle opens)
+ * - Candle with timestamp 00:00 covers period [00:00, 00:15) for 15m interval
+ *
+ * Adapter contract:
+ * - Adapter must return candles with timestamp = openTime
+ * - First returned candle.timestamp must equal aligned since
+ * - Adapter must return exactly `limit` candles
+ *
+ * @param timestamp - Timestamp in milliseconds
+ * @param intervalMinutes - Interval in minutes
+ * @returns Aligned timestamp rounded down to interval boundary
+ */
+const ALIGN_TO_INTERVAL_FN = (timestamp, intervalMinutes) => {
+    const intervalMs = intervalMinutes * MS_PER_MINUTE;
+    return Math.floor(timestamp / intervalMs) * intervalMs;
+};
 /**
  * Creates exchange instance with methods resolved once during construction.
  * Applies default implementations where schema methods are not provided.
@@ -33110,25 +33735,24 @@ const CREATE_EXCHANGE_INSTANCE_FN = (schema) => {
 };
 /**
  * Attempts to read candles from cache.
- * Validates cache consistency (no gaps in timestamps) before returning.
  *
- * Boundary semantics:
- * - sinceTimestamp: EXCLUSIVE lower bound (candle.timestamp > sinceTimestamp)
- * - untilTimestamp: EXCLUSIVE upper bound (candle.timestamp + stepMs < untilTimestamp)
- * - Only fully closed candles within the exclusive range are returned
+ * Cache lookup calculates expected timestamps:
+ * sinceTimestamp + i * stepMs for i = 0..limit-1
+ * Returns all candles if found, null if any missing.
  *
  * @param dto - Data transfer object containing symbol, interval, and limit
- * @param sinceTimestamp - Exclusive start timestamp in milliseconds
- * @param untilTimestamp - Exclusive end timestamp in milliseconds
+ * @param sinceTimestamp - Aligned start timestamp (openTime of first candle)
+ * @param untilTimestamp - Unused, kept for API compatibility
  * @param exchangeName - Exchange name
- * @returns Cached candles array or null if cache miss or inconsistent
+ * @returns Cached candles array (exactly limit) or null if cache miss
  */
 const READ_CANDLES_CACHE_FN = trycatch(async (dto, sinceTimestamp, untilTimestamp, exchangeName) => {
-    // PersistCandleAdapter.readCandlesData uses EXCLUSIVE boundaries:
-    // Returns candles where: timestamp > sinceTimestamp AND timestamp + stepMs < untilTimestamp
+    // PersistCandleAdapter.readCandlesData calculates expected timestamps:
+    // sinceTimestamp + i * stepMs for i = 0..limit-1
+    // Returns all candles if found, null if any missing
     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) {
+    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;
     }
@@ -33150,11 +33774,12 @@ const READ_CANDLES_CACHE_FN = trycatch(async (dto, sinceTimestamp, untilTimestam
 /**
  * Writes candles to cache with error handling.
  *
- * The candles passed to this function must already be filtered using EXCLUSIVE boundaries:
- * - candle.timestamp > sinceTimestamp
- * - candle.timestamp + stepMs < untilTimestamp
+ * The candles passed to this function should be validated:
+ * - First candle.timestamp equals aligned sinceTimestamp (openTime)
+ * - Exact number of candles as requested (limit)
+ * - Sequential timestamps: sinceTimestamp + i * stepMs
  *
- * @param candles - Array of candle data to cache (already filtered with exclusive boundaries)
+ * @param candles - Array of validated candle data to cache
  * @param dto - Data transfer object containing symbol, interval, and limit
  * @param exchangeName - Exchange name
  */
@@ -33225,14 +33850,18 @@ class ExchangeInstance {
             });
             const getCandles = this._methods.getCandles;
             const step = INTERVAL_MINUTES$1[interval];
-            const adjust = step * limit;
-            if (!adjust) {
-                throw new Error(`ExchangeInstance unknown time adjust for interval=${interval}`);
+            if (!step) {
+                throw new Error(`ExchangeInstance unknown interval=${interval}`);
             }
+            const stepMs = step * MS_PER_MINUTE;
+            // Align when down to interval boundary
             const when = await GET_TIMESTAMP_FN();
-            const since = new Date(when.getTime() - adjust * MS_PER_MINUTE);
-            const sinceTimestamp = since.getTime();
-            const untilTimestamp = sinceTimestamp + limit * step * MS_PER_MINUTE;
+            const whenTimestamp = when.getTime();
+            const alignedWhen = ALIGN_TO_INTERVAL_FN(whenTimestamp, step);
+            // Calculate since: go back limit candles from aligned when
+            const sinceTimestamp = alignedWhen - limit * stepMs;
+            const since = new Date(sinceTimestamp);
+            const untilTimestamp = alignedWhen;
             // Try to read from cache first
             const cachedCandles = await READ_CANDLES_CACHE_FN({ symbol, interval, limit }, sinceTimestamp, untilTimestamp, this.exchangeName);
             if (cachedCandles !== null) {
@@ -33251,7 +33880,7 @@ class ExchangeInstance {
                     remaining -= chunkLimit;
                     if (remaining > 0) {
                         // Move currentSince forward by the number of candles fetched
-                        currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE);
+                        currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
                     }
                 }
             }
@@ -33259,27 +33888,25 @@ class ExchangeInstance {
                 const isBacktest = await GET_BACKTEST_FN();
                 allData = await getCandles(symbol, interval, since, limit, isBacktest);
             }
-            // Filter candles to strictly match the requested range
-            const whenTimestamp = when.getTime();
-            const stepMs = step * MS_PER_MINUTE;
-            const filteredData = allData.filter((candle) => {
-                // EXCLUSIVE boundaries:
-                // - candle.timestamp > sinceTimestamp (exclude exact boundary)
-                // - candle.timestamp + stepMs < whenTimestamp (fully closed before "when")
-                if (candle.timestamp <= sinceTimestamp) {
-                    return false;
-                }
-                // Check against current time (when)
-                // Only allow candles that have fully CLOSED before "when"
-                return candle.timestamp + stepMs < 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) {
-                bt.loggerService.warn(`ExchangeInstance Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`);
+            const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
+            if (allData.length !== uniqueData.length) {
+                bt.loggerService.warn(`ExchangeInstance getCandles: Removed ${allData.length - uniqueData.length} duplicate candles by timestamp`);
+            }
+            // Validate adapter returned data
+            if (uniqueData.length === 0) {
+                throw new Error(`ExchangeInstance getCandles: adapter returned empty array. ` +
+                    `Expected ${limit} candles starting from openTime=${sinceTimestamp}.`);
             }
-            if (uniqueData.length < limit) {
-                bt.loggerService.warn(`ExchangeInstance Expected ${limit} candles, got ${uniqueData.length}`);
+            if (uniqueData[0].timestamp !== sinceTimestamp) {
+                throw new Error(`ExchangeInstance getCandles: first candle timestamp mismatch. ` +
+                    `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
+                    `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
+            }
+            if (uniqueData.length !== limit) {
+                throw new Error(`ExchangeInstance getCandles: candle count mismatch. ` +
+                    `Expected ${limit} candles, got ${uniqueData.length}. ` +
+                    `Adapter must return exact number of candles requested.`);
             }
             // Write to cache after successful fetch
             await WRITE_CANDLES_CACHE_FN(uniqueData, { symbol, interval, limit }, this.exchangeName);
@@ -33450,10 +34077,11 @@ class ExchangeInstance {
             if (!step) {
                 throw new Error(`ExchangeInstance getRawCandles: unknown interval=${interval}`);
             }
+            const stepMs = step * MS_PER_MINUTE;
             const when = await GET_TIMESTAMP_FN();
             const nowTimestamp = when.getTime();
+            const alignedNow = ALIGN_TO_INTERVAL_FN(nowTimestamp, step);
             let sinceTimestamp;
-            let untilTimestamp;
             let calculatedLimit;
             // Case 1: all three parameters provided
             if (sDate !== undefined && eDate !== undefined && limit !== undefined) {
@@ -33463,8 +34091,8 @@ class ExchangeInstance {
                 if (eDate > nowTimestamp) {
                     throw new Error(`ExchangeInstance getRawCandles: eDate (${eDate}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
                 }
-                sinceTimestamp = sDate;
-                untilTimestamp = eDate;
+                // Align sDate down to interval boundary
+                sinceTimestamp = ALIGN_TO_INTERVAL_FN(sDate, step);
                 calculatedLimit = limit;
             }
             // Case 2: sDate + eDate (no limit) - calculate limit from date range
@@ -33475,9 +34103,10 @@ class ExchangeInstance {
                 if (eDate > nowTimestamp) {
                     throw new Error(`ExchangeInstance getRawCandles: eDate (${eDate}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
                 }
-                sinceTimestamp = sDate;
-                untilTimestamp = eDate;
-                calculatedLimit = Math.ceil((eDate - sDate) / (step * MS_PER_MINUTE));
+                // Align sDate down to interval boundary
+                sinceTimestamp = ALIGN_TO_INTERVAL_FN(sDate, step);
+                const alignedEDate = ALIGN_TO_INTERVAL_FN(eDate, step);
+                calculatedLimit = Math.ceil((alignedEDate - sinceTimestamp) / stepMs);
                 if (calculatedLimit <= 0) {
                     throw new Error(`ExchangeInstance getRawCandles: calculated limit is ${calculatedLimit}, must be > 0`);
                 }
@@ -33487,23 +34116,24 @@ class ExchangeInstance {
                 if (eDate > nowTimestamp) {
                     throw new Error(`ExchangeInstance getRawCandles: eDate (${eDate}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
                 }
-                untilTimestamp = eDate;
-                sinceTimestamp = eDate - limit * step * MS_PER_MINUTE;
+                // Align eDate down and calculate sinceTimestamp
+                const alignedEDate = ALIGN_TO_INTERVAL_FN(eDate, step);
+                sinceTimestamp = alignedEDate - limit * stepMs;
                 calculatedLimit = limit;
             }
             // Case 4: sDate + limit (no eDate) - calculate eDate forward from sDate
             else if (sDate !== undefined && eDate === undefined && limit !== undefined) {
-                sinceTimestamp = sDate;
-                untilTimestamp = sDate + limit * step * MS_PER_MINUTE;
-                if (untilTimestamp > nowTimestamp) {
-                    throw new Error(`ExchangeInstance getRawCandles: calculated endTimestamp (${untilTimestamp}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
+                // Align sDate down to interval boundary
+                sinceTimestamp = ALIGN_TO_INTERVAL_FN(sDate, step);
+                const endTimestamp = sinceTimestamp + limit * stepMs;
+                if (endTimestamp > nowTimestamp) {
+                    throw new Error(`ExchangeInstance getRawCandles: calculated endTimestamp (${endTimestamp}) exceeds current time (${nowTimestamp}). Look-ahead bias protection.`);
                 }
                 calculatedLimit = limit;
             }
             // Case 5: Only limit - use Date.now() as reference (backward)
             else if (sDate === undefined && eDate === undefined && limit !== undefined) {
-                untilTimestamp = nowTimestamp;
-                sinceTimestamp = nowTimestamp - limit * step * MS_PER_MINUTE;
+                sinceTimestamp = alignedNow - limit * stepMs;
                 calculatedLimit = limit;
             }
             // Invalid: no parameters or only sDate or only eDate
@@ -33513,6 +34143,7 @@ class ExchangeInstance {
                     `Got: sDate=${sDate}, eDate=${eDate}, limit=${limit}`);
             }
             // Try to read from cache first
+            const untilTimestamp = sinceTimestamp + calculatedLimit * stepMs;
             const cachedCandles = await READ_CANDLES_CACHE_FN({ symbol, interval, limit: calculatedLimit }, sinceTimestamp, untilTimestamp, this.exchangeName);
             if (cachedCandles !== null) {
                 return cachedCandles;
@@ -33531,25 +34162,32 @@ class ExchangeInstance {
                     allData.push(...chunkData);
                     remaining -= chunkLimit;
                     if (remaining > 0) {
-                        currentSince = new Date(currentSince.getTime() + chunkLimit * step * MS_PER_MINUTE);
+                        currentSince = new Date(currentSince.getTime() + chunkLimit * stepMs);
                     }
                 }
             }
             else {
                 allData = await getCandles(symbol, interval, since, calculatedLimit, isBacktest);
             }
-            // Filter candles to strictly match the requested range
-            // Only include candles that have fully CLOSED before untilTimestamp
-            const stepMs = step * MS_PER_MINUTE;
-            const filteredData = allData.filter((candle) => candle.timestamp > sinceTimestamp &&
-                candle.timestamp + stepMs < untilTimestamp);
             // 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) {
-                bt.loggerService.warn(`ExchangeInstance getRawCandles: Removed ${filteredData.length - uniqueData.length} duplicate candles by timestamp`);
+            const uniqueData = Array.from(new Map(allData.map((candle) => [candle.timestamp, candle])).values());
+            if (allData.length !== uniqueData.length) {
+                bt.loggerService.warn(`ExchangeInstance getRawCandles: Removed ${allData.length - uniqueData.length} duplicate candles by timestamp`);
+            }
+            // Validate adapter returned data
+            if (uniqueData.length === 0) {
+                throw new Error(`ExchangeInstance getRawCandles: adapter returned empty array. ` +
+                    `Expected ${calculatedLimit} candles starting from openTime=${sinceTimestamp}.`);
             }
-            if (uniqueData.length < calculatedLimit) {
-                bt.loggerService.warn(`ExchangeInstance getRawCandles: Expected ${calculatedLimit} candles, got ${uniqueData.length}`);
+            if (uniqueData[0].timestamp !== sinceTimestamp) {
+                throw new Error(`ExchangeInstance getRawCandles: first candle timestamp mismatch. ` +
+                    `Expected openTime=${sinceTimestamp}, got=${uniqueData[0].timestamp}. ` +
+                    `Adapter must return candles with timestamp=openTime, starting from aligned since.`);
+            }
+            if (uniqueData.length !== calculatedLimit) {
+                throw new Error(`ExchangeInstance getRawCandles: candle count mismatch. ` +
+                    `Expected ${calculatedLimit} candles, got ${uniqueData.length}. ` +
+                    `Adapter must return exact number of candles requested.`);
             }
             // Write to cache after successful fetch
             await WRITE_CANDLES_CACHE_FN(uniqueData, { symbol, interval, limit: calculatedLimit }, this.exchangeName);
@@ -34341,6 +34979,29 @@ class NotificationInstance {
                     createdAt: data.timestamp,
                 });
             }
+            else if (data.action === "activate-scheduled") {
+                this._addNotification({
+                    type: "activate_scheduled.commit",
+                    id: CREATE_KEY_FN(),
+                    timestamp: data.timestamp,
+                    backtest: data.backtest,
+                    symbol: data.symbol,
+                    strategyName: data.strategyName,
+                    exchangeName: data.exchangeName,
+                    signalId: data.signalId,
+                    activateId: data.activateId,
+                    currentPrice: data.currentPrice,
+                    position: data.position,
+                    priceOpen: data.priceOpen,
+                    priceTakeProfit: data.priceTakeProfit,
+                    priceStopLoss: data.priceStopLoss,
+                    originalPriceTakeProfit: data.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.originalPriceStopLoss,
+                    scheduledAt: data.scheduledAt,
+                    pendingAt: data.pendingAt,
+                    createdAt: data.timestamp,
+                });
+            }
         };
         /**
          * Processes risk rejection events.
@@ -35145,4 +35806,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitActivateScheduled, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getNextCandles, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };