backtest-kit 2.3.1 → 2.3.3

package/build/index.cjs

@@ -1578,73 +1578,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: functoolsKit.errorData(error),
-                            message: functoolsKit.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 functoolsKit.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: functoolsKit.errorData(error),
+                        message: functoolsKit.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
@@ -1661,8 +1661,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 functoolsKit.not(stateStorage.hasValue(String(candle.timestamp)))) {
                     await stateStorage.writeValue(String(candle.timestamp), candle);
                 }
@@ -1820,6 +1837,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.
@@ -1883,25 +1921,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 = functoolsKit.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;
     }
@@ -1923,11 +1960,12 @@ const READ_CANDLES_CACHE_FN$1 = functoolsKit.trycatch(async (dto, sinceTimestamp
 /**
  * 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
  */
@@ -2054,6 +2092,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
@@ -2066,11 +2111,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) {
@@ -2083,39 +2133,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;
@@ -2124,6 +2169,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
@@ -2139,12 +2191,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 [];
         }
@@ -2160,29 +2221,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;
@@ -2257,6 +2323,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:
@@ -2291,9 +2363,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) {
@@ -2303,8 +2376,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
@@ -2315,9 +2388,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`);
             }
@@ -2327,23 +2401,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
@@ -2364,29 +2439,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;
@@ -4944,6 +5024,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 functoolsKit.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) {
@@ -5166,6 +5308,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 = [];
         /**
@@ -5203,6 +5346,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
@@ -5228,6 +5381,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;
@@ -5417,12 +5575,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;
@@ -5431,6 +5585,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 = {
@@ -5459,6 +5625,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 при закрытии позиции
@@ -5485,6 +5663,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 functoolsKit.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);
@@ -5508,7 +5758,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) {
@@ -5582,6 +5837,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",
@@ -5607,6 +5874,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);
@@ -5767,8 +6046,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;
@@ -5806,8 +6095,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,
@@ -5815,37 +6105,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.
@@ -5874,8 +6187,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,
@@ -5883,37 +6196,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).
@@ -7752,6 +8039,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);
+        };
     }
 }
 
@@ -11064,6 +11384,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);
+        };
     }
 }
 
@@ -12343,13 +12696,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.
  *
@@ -12473,9 +12821,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);
@@ -12613,9 +12961,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);
@@ -24303,6 +24651,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.
          *
@@ -24362,7 +24771,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 = functoolsKit.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 = functoolsKit.compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled());
             return () => {
                 disposeFn();
                 this.subscribe.clear();
@@ -24493,6 +24909,7 @@ class ReportStorage {
                 trailingStopCount: 0,
                 trailingTakeCount: 0,
                 breakevenCount: 0,
+                activateScheduledCount: 0,
             };
         }
         return {
@@ -24505,6 +24922,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,
         };
     }
     /**
@@ -24553,6 +24971,7 @@ class ReportStorage {
             `- Trailing stop: ${stats.trailingStopCount}`,
             `- Trailing take: ${stats.trailingTakeCount}`,
             `- Breakeven: ${stats.breakevenCount}`,
+            `- Activate scheduled: ${stats.activateScheduledCount}`,
         ].join("\n");
     }
     /**
@@ -25019,6 +25438,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.
          *
@@ -25192,7 +25671,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 = functoolsKit.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 = functoolsKit.compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven(), () => unActivateScheduled());
             return () => {
                 disposeFn();
                 this.subscribe.clear();
@@ -26118,6 +26604,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.
  *
@@ -26435,6 +26922,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";
 /**
@@ -28605,6 +29127,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.
@@ -29461,6 +29984,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.
          *
@@ -29636,6 +30199,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.
@@ -30460,6 +31024,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.
          *
@@ -33109,6 +33713,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.
@@ -33130,25 +33755,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 = functoolsKit.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;
     }
@@ -33170,11 +33794,12 @@ const READ_CANDLES_CACHE_FN = functoolsKit.trycatch(async (dto, sinceTimestamp,
 /**
  * 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
  */
@@ -33245,14 +33870,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) {
@@ -33271,7 +33900,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);
                     }
                 }
             }
@@ -33279,27 +33908,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);
@@ -33470,10 +34097,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) {
@@ -33483,8 +34111,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
@@ -33495,9 +34123,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`);
                 }
@@ -33507,23 +34136,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
@@ -33533,6 +34163,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;
@@ -33551,25 +34182,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);
@@ -34361,6 +34999,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.
@@ -35206,6 +35867,7 @@ exports.addRiskSchema = addRiskSchema;
 exports.addSizingSchema = addSizingSchema;
 exports.addStrategySchema = addStrategySchema;
 exports.addWalkerSchema = addWalkerSchema;
+exports.commitActivateScheduled = commitActivateScheduled;
 exports.commitBreakeven = commitBreakeven;
 exports.commitCancelScheduled = commitCancelScheduled;
 exports.commitClosePending = commitClosePending;