backtest-kit 5.9.0 → 5.10.0

package/build/index.cjs

@@ -6345,7 +6345,7 @@ const CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN = async (self, closedSignal, aver
     await CALL_TICK_CALLBACKS_FN(self, self.params.execution.context.symbol, result, closeTimestamp, self.params.execution.context.backtest);
     return result;
 };
-const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) => {
+const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles, frameEndTime) => {
     const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
     const maxTimeToWait = GLOBAL_CONFIG.CC_SCHEDULE_AWAIT_MINUTES * 60 * 1000;
     const bufferCandlesCount = candlesCount - 1;
@@ -6358,6 +6358,11 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
         }
         const recentCandles = candles.slice(Math.max(0, i - (candlesCount - 1)), i + 1);
         const averagePrice = GET_AVG_PRICE_FN(recentCandles);
+        // Если timestamp свечи вышел за frameEndTime — отменяем scheduled сигнал
+        if (candle.timestamp > frameEndTime) {
+            const result = await CANCEL_SCHEDULED_SIGNAL_IN_BACKTEST_FN(self, scheduled, averagePrice, candle.timestamp, "timeout");
+            return { outcome: "cancelled", result };
+        }
         // КРИТИЧНО: Проверяем был ли сигнал отменен пользователем через cancel()
         if (self._cancelledSignal) {
             // Сигнал был отменен через cancel() в onSchedulePing
@@ -6505,7 +6510,7 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
     }
     return { outcome: "pending" };
 };
-const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
+const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles, frameEndTime) => {
     const candlesCount = GLOBAL_CONFIG.CC_AVG_PRICE_CANDLES_COUNT;
     const bufferCandlesCount = candlesCount - 1;
     // КРИТИЧНО: проверяем TP/SL на КАЖДОЙ свече начиная после буфера
@@ -6522,6 +6527,14 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
         const startIndex = Math.max(0, i - (candlesCount - 1));
         const recentCandles = candles.slice(startIndex, i + 1);
         const averagePrice = GET_AVG_PRICE_FN(recentCandles);
+        // Если timestamp свечи вышел за frameEndTime — закрываем pending сигнал по time_expired
+        if (currentCandleTimestamp > frameEndTime) {
+            const result = await CLOSE_PENDING_SIGNAL_IN_BACKTEST_FN(self, signal, averagePrice, "time_expired", currentCandleTimestamp);
+            if (!result) {
+                throw new Error(`ClientStrategy backtest: frameEndTime time_expired close rejected by sync (signalId=${signal.id}).`);
+            }
+            return result;
+        }
         // КРИТИЧНО: Проверяем был ли сигнал закрыт пользователем через closePending()
         if (self._closedSignal) {
             return await CLOSE_USER_PENDING_SIGNAL_IN_BACKTEST_FN(self, self._closedSignal, averagePrice, currentCandleTimestamp);
@@ -7687,7 +7700,7 @@ class ClientStrategy {
      * console.log(result.closeReason); // "take_profit" | "stop_loss" | "time_expired" | "cancelled"
      * ```
      */
-    async backtest(symbol, strategyName, candles) {
+    async backtest(symbol, strategyName, candles, frameEndTime) {
         this.params.logger.debug("ClientStrategy backtest", {
             symbol,
             strategyName,
@@ -7695,6 +7708,7 @@ class ClientStrategy {
             candlesCount: candles.length,
             hasScheduled: !!this._scheduledSignal,
             hasPending: !!this._pendingSignal,
+            frameEndTime,
         });
         if (!this.params.execution.context.backtest) {
             throw new Error("ClientStrategy backtest: running in live context");
@@ -7813,7 +7827,7 @@ class ClientStrategy {
                 priceOpen: scheduled.priceOpen,
                 position: scheduled.position,
             });
-            const scheduledResult = await PROCESS_SCHEDULED_SIGNAL_CANDLES_FN(this, scheduled, candles);
+            const scheduledResult = await PROCESS_SCHEDULED_SIGNAL_CANDLES_FN(this, scheduled, candles, frameEndTime);
             if (scheduledResult.outcome === "cancelled") {
                 return scheduledResult.result;
             }
@@ -7890,7 +7904,7 @@ class ClientStrategy {
         if (candles.length < candlesCount) {
             this.params.logger.warn(`ClientStrategy backtest: Expected at least ${candlesCount} candles for VWAP, got ${candles.length}`);
         }
-        return await PROCESS_PENDING_SIGNAL_CANDLES_FN(this, signal, candles);
+        return await PROCESS_PENDING_SIGNAL_CANDLES_FN(this, signal, candles, frameEndTime);
     }
     /**
      * Stops the strategy from generating new signals.
@@ -10283,17 +10297,18 @@ class StrategyConnectionService {
          * @param candles - Array of historical candle data to backtest
          * @returns Promise resolving to backtest result (signal or idle)
          */
-        this.backtest = async (symbol, context, candles) => {
+        this.backtest = async (symbol, context, candles, frameEndTime) => {
             const backtest = this.executionContextService.context.backtest;
             this.loggerService.log("strategyConnectionService backtest", {
                 symbol,
                 context,
                 candleCount: candles.length,
+                frameEndTime,
                 backtest,
             });
             const strategy = this.getStrategy(symbol, context.strategyName, context.exchangeName, context.frameName, backtest);
             await strategy.waitForInit();
-            const tick = await strategy.backtest(symbol, context.strategyName, candles);
+            const tick = await strategy.backtest(symbol, context.strategyName, candles, frameEndTime);
             {
                 await CALL_SIGNAL_EMIT_FN(this, tick, context, backtest, symbol);
             }
@@ -14228,17 +14243,18 @@ class StrategyCoreService {
          * @param context - Execution context with strategyName, exchangeName, frameName
          * @returns Closed signal result with PNL
          */
-        this.backtest = async (symbol, candles, when, backtest, context) => {
+        this.backtest = async (symbol, candles, frameEndTime, when, backtest, context) => {
             this.loggerService.log("strategyCoreService backtest", {
                 symbol,
                 candleCount: candles.length,
                 when,
                 backtest,
                 context,
+                frameEndTime,
             });
             await this.validate(context);
             return await ExecutionContextService.runInContext(async () => {
-                return await this.strategyConnectionService.backtest(symbol, context, candles);
+                return await this.strategyConnectionService.backtest(symbol, context, candles, frameEndTime);
             }, {
                 symbol,
                 when,
@@ -16231,7 +16247,9 @@ const TICK_FN = async (self, symbol, when) => {
         });
     }
     catch (error) {
-        console.error(`backtestLogicPrivateService tick failed symbol=${symbol} when=${when.toISOString()} strategyName=${self.methodContextService.context.strategyName} exchangeName=${self.methodContextService.context.exchangeName}`);
+        console.error(`backtestLogicPrivateService tick failed symbol=${symbol} when=${when.toISOString()} strategyName=${self.methodContextService.context.strategyName} exchangeName=${self.methodContextService.context.exchangeName} error=${functoolsKit.getErrorMessage(error)}`, {
+            error: functoolsKit.errorData(error),
+        });
         self.loggerService.warn("backtestLogicPrivateService tick failed", {
             symbol,
             when: when.toISOString(),
@@ -16257,9 +16275,9 @@ const GET_CANDLES_FN = async (self, symbol, candlesNeeded, bufferStartTime, logM
         return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "GET_CANDLES_FN", message: functoolsKit.getErrorMessage(error) };
     }
 };
-const BACKTEST_FN = async (self, symbol, candles, when, context, logMeta) => {
+const BACKTEST_FN = async (self, symbol, candles, frameEndTime, when, context, logMeta) => {
     try {
-        return await self.strategyCoreService.backtest(symbol, candles, when, true, context);
+        return await self.strategyCoreService.backtest(symbol, candles, frameEndTime, when, true, context);
     }
     catch (error) {
         console.error(`backtestLogicPrivateService backtest failed symbol=${symbol} when=${when.toISOString()} strategyName=${context.strategyName} exchangeName=${context.exchangeName}`);
@@ -16272,7 +16290,29 @@ const BACKTEST_FN = async (self, symbol, candles, when, context, logMeta) => {
         return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "BACKTEST_FN", message: functoolsKit.getErrorMessage(error) };
     }
 };
-const RUN_INFINITY_CHUNK_LOOP_FN = async (self, symbol, when, context, initialResult, bufferMs, signalId) => {
+const CLOSE_PENDING_FN = async (self, symbol, context, lastChunkCandles, frameEndTime, when, signalId) => {
+    try {
+        await self.strategyCoreService.closePending(true, symbol, context);
+    }
+    catch (error) {
+        const message = `closePending failed: ${functoolsKit.getErrorMessage(error)}`;
+        console.error(`backtestLogicPrivateService CLOSE_PENDING_FN: ${message} symbol=${symbol}`);
+        await errorEmitter.next(error instanceof Error ? error : new Error(message));
+        return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "CLOSE_PENDING_FN", message };
+    }
+    const result = await BACKTEST_FN(self, symbol, lastChunkCandles, frameEndTime, when, context, { signalId });
+    if ("__error__" in result) {
+        return result;
+    }
+    if (result.action === "active") {
+        const message = `signal ${signalId} still active after closePending`;
+        console.error(`backtestLogicPrivateService CLOSE_PENDING_FN: ${message} symbol=${symbol}`);
+        await errorEmitter.next(new Error(message));
+        return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "CLOSE_PENDING_FN", message };
+    }
+    return result;
+};
+const RUN_INFINITY_CHUNK_LOOP_FN = async (self, symbol, when, context, initialResult, bufferMs, signalId, frameEndTime) => {
     let backtestResult = initialResult;
     const CHUNK = GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST;
     let lastChunkCandles = [];
@@ -16283,25 +16323,14 @@ const RUN_INFINITY_CHUNK_LOOP_FN = async (self, symbol, when, context, initialRe
             return chunkCandles;
         }
         if (!chunkCandles.length) {
-            await self.strategyCoreService.closePending(true, symbol, context);
-            const result = await BACKTEST_FN(self, symbol, lastChunkCandles, when, context, { signalId });
-            if ("__error__" in result) {
-                return result;
-            }
-            if (result.action === "active") {
-                const message = `signal ${signalId} still active after closePending`;
-                console.error(`backtestLogicPrivateService RUN_INFINITY_CHUNK_LOOP_FN: ${message} symbol=${symbol}`);
-                await errorEmitter.next(new Error(message));
-                return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "RUN_INFINITY_CHUNK_LOOP_FN", message };
-            }
-            return result;
+            return await CLOSE_PENDING_FN(self, symbol, context, lastChunkCandles, frameEndTime, when, signalId);
         }
         self.loggerService.info("backtestLogicPrivateService candles fetched for infinity chunk", {
             symbol,
             signalId,
             candlesCount: chunkCandles.length,
         });
-        const chunkResult = await BACKTEST_FN(self, symbol, chunkCandles, when, context, { signalId });
+        const chunkResult = await BACKTEST_FN(self, symbol, chunkCandles, frameEndTime, when, context, { signalId });
         if ("__error__" in chunkResult) {
             return chunkResult;
         }
@@ -16346,7 +16375,7 @@ const EMIT_TIMEFRAME_PERFORMANCE_FN = async (self, symbol, timeframeStartTime, p
     });
     return currentTimestamp;
 };
-const PROCESS_SCHEDULED_SIGNAL_FN = async function* (self, symbol, when, result, previousEventTimestamp) {
+const PROCESS_SCHEDULED_SIGNAL_FN = async function* (self, symbol, when, result, previousEventTimestamp, frameEndTime) {
     const signalStartTime = performance.now();
     const signal = result.signal;
     self.loggerService.info("backtestLogicPrivateService scheduled signal detected", {
@@ -16366,6 +16395,10 @@ const PROCESS_SCHEDULED_SIGNAL_FN = async function* (self, symbol, when, result,
         console.error(`backtestLogicPrivateService scheduled signal: getCandles failed, stopping backtest symbol=${symbol} signalId=${signal.id} reason=${candles.reason} message=${candles.message}`);
         return candles;
     }
+    // No candles available for this scheduled signal — the frame ends before the signal
+    // could be evaluated. Unlike pending (Infinity) signals that require CLOSE_PENDING_FN,
+    // a scheduled signal that never activated needs no explicit cancellation: it simply
+    // did not start. Returning "skip" moves the backtest to the next timeframe.
     if (!candles.length) {
         return { type: "skip" };
     }
@@ -16407,7 +16440,7 @@ const PROCESS_SCHEDULED_SIGNAL_FN = async function* (self, symbol, when, result,
         });
     }
     try {
-        const firstResult = await BACKTEST_FN(self, symbol, candles, when, context, { signalId: signal.id });
+        const firstResult = await BACKTEST_FN(self, symbol, candles, frameEndTime, when, context, { signalId: signal.id });
         if ("__error__" in firstResult) {
             console.error(`backtestLogicPrivateService scheduled signal: backtest failed, stopping backtest symbol=${symbol} signalId=${signal.id} reason=${firstResult.reason} message=${firstResult.message}`);
             return firstResult;
@@ -16419,7 +16452,7 @@ const PROCESS_SCHEDULED_SIGNAL_FN = async function* (self, symbol, when, result,
     }
     if (backtestResult.action === "active" && signal.minuteEstimatedTime === Infinity) {
         const bufferMs = bufferMinutes * 60000;
-        const chunkResult = await RUN_INFINITY_CHUNK_LOOP_FN(self, symbol, when, context, backtestResult, bufferMs, signal.id);
+        const chunkResult = await RUN_INFINITY_CHUNK_LOOP_FN(self, symbol, when, context, backtestResult, bufferMs, signal.id, frameEndTime);
         if ("__error__" in chunkResult) {
             console.error(`backtestLogicPrivateService scheduled signal: infinity chunk loop failed, stopping backtest symbol=${symbol} signalId=${signal.id} reason=${chunkResult.reason} message=${chunkResult.message}`);
             return chunkResult;
@@ -16449,7 +16482,7 @@ const PROCESS_SCHEDULED_SIGNAL_FN = async function* (self, symbol, when, result,
     yield backtestResult;
     return { type: "closed", previousEventTimestamp: newTimestamp, closeTimestamp: backtestResult.closeTimestamp, shouldStop };
 };
-const RUN_OPENED_CHUNK_LOOP_FN = async (self, symbol, when, context, bufferStartTime, bufferMs, signalId) => {
+const RUN_OPENED_CHUNK_LOOP_FN = async (self, symbol, when, context, bufferStartTime, bufferMs, signalId, frameEndTime) => {
     const CHUNK = GLOBAL_CONFIG.CC_MAX_CANDLES_PER_REQUEST;
     let chunkStart = bufferStartTime;
     let lastChunkCandles = [];
@@ -16470,29 +16503,14 @@ const RUN_OPENED_CHUNK_LOOP_FN = async (self, symbol, when, context, bufferStart
                 await errorEmitter.next(new Error(message));
                 return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "RUN_OPENED_CHUNK_LOOP_FN", message };
             }
-            await self.strategyCoreService.closePending(true, symbol, context);
-            const result = await BACKTEST_FN(self, symbol, lastChunkCandles, when, context, { signalId });
-            if ("__error__" in result) {
-                return result;
-            }
-            if (result.action === "active") {
-                const message = `signal ${signalId} still active after closePending`;
-                console.error(`backtestLogicPrivateService RUN_OPENED_CHUNK_LOOP_FN: ${message} symbol=${symbol}`);
-                self.loggerService.warn("backtestLogicPrivateService opened infinity: signal still active after closePending", {
-                    symbol,
-                    signalId,
-                });
-                await errorEmitter.next(new Error(message));
-                return { type: "error", __error__: SYMBOL_FN_ERROR, reason: "RUN_OPENED_CHUNK_LOOP_FN", message };
-            }
-            return result;
+            return await CLOSE_PENDING_FN(self, symbol, context, lastChunkCandles, frameEndTime, when, signalId);
         }
         self.loggerService.info("backtestLogicPrivateService candles fetched", {
             symbol,
             signalId,
             candlesCount: chunkCandles.length,
         });
-        const chunkResult = await BACKTEST_FN(self, symbol, chunkCandles, when, context, { signalId });
+        const chunkResult = await BACKTEST_FN(self, symbol, chunkCandles, frameEndTime, when, context, { signalId });
         if ("__error__" in chunkResult) {
             return chunkResult;
         }
@@ -16503,7 +16521,7 @@ const RUN_OPENED_CHUNK_LOOP_FN = async (self, symbol, when, context, bufferStart
         chunkStart = new Date(chunkResult._backtestLastTimestamp + 60000 - bufferMs);
     }
 };
-const PROCESS_OPENED_SIGNAL_FN = async function* (self, symbol, when, result, previousEventTimestamp) {
+const PROCESS_OPENED_SIGNAL_FN = async function* (self, symbol, when, result, previousEventTimestamp, frameEndTime) {
     const signalStartTime = performance.now();
     const signal = result.signal;
     self.loggerService.info("backtestLogicPrivateService signal opened", {
@@ -16534,7 +16552,7 @@ const PROCESS_OPENED_SIGNAL_FN = async function* (self, symbol, when, result, pr
             signalId: signal.id,
             candlesCount: candles.length,
         });
-        const firstResult = await BACKTEST_FN(self, symbol, candles, when, context, { signalId: signal.id });
+        const firstResult = await BACKTEST_FN(self, symbol, candles, frameEndTime, when, context, { signalId: signal.id });
         if ("__error__" in firstResult) {
             console.error(`backtestLogicPrivateService opened signal: backtest failed, stopping backtest symbol=${symbol} signalId=${signal.id} reason=${firstResult.reason} message=${firstResult.message}`);
             return firstResult;
@@ -16543,7 +16561,7 @@ const PROCESS_OPENED_SIGNAL_FN = async function* (self, symbol, when, result, pr
     }
     else {
         const bufferMs = bufferMinutes * 60000;
-        const chunkResult = await RUN_OPENED_CHUNK_LOOP_FN(self, symbol, when, context, bufferStartTime, bufferMs, signal.id);
+        const chunkResult = await RUN_OPENED_CHUNK_LOOP_FN(self, symbol, when, context, bufferStartTime, bufferMs, signal.id, frameEndTime);
         if ("__error__" in chunkResult) {
             console.error(`backtestLogicPrivateService opened signal: chunk loop failed, stopping backtest symbol=${symbol} signalId=${signal.id} reason=${chunkResult.reason} message=${chunkResult.message}`);
             return chunkResult;
@@ -16609,86 +16627,103 @@ class BacktestLogicPrivateService {
             symbol,
         });
         const backtestStartTime = performance.now();
+        let _fatalError = null;
+        let previousEventTimestamp = null;
         const timeframes = await this.frameCoreService.getTimeframe(symbol, this.methodContextService.context.frameName);
         const totalFrames = timeframes.length;
+        let frameEndTime = timeframes[totalFrames - 1].getTime();
         let i = 0;
-        let previousEventTimestamp = null;
-        while (i < timeframes.length) {
-            const timeframeStartTime = performance.now();
-            const when = timeframes[i];
-            await EMIT_PROGRESS_FN(this, symbol, totalFrames, i);
-            if (await CHECK_STOPPED_FN(this, symbol, "before tick", { when: when.toISOString(), processedFrames: i, totalFrames })) {
-                break;
-            }
-            const result = await TICK_FN(this, symbol, when);
-            if ("__error__" in result) {
-                break;
-            }
-            if (result.action === "idle" &&
-                await functoolsKit.and(Promise.resolve(true), this.strategyCoreService.getStopped(true, symbol, {
-                    strategyName: this.methodContextService.context.strategyName,
-                    exchangeName: this.methodContextService.context.exchangeName,
-                    frameName: this.methodContextService.context.frameName,
-                }))) {
-                this.loggerService.info("backtestLogicPrivateService stopped by user request (idle state)", {
-                    symbol,
-                    when: when.toISOString(),
-                    processedFrames: i,
-                    totalFrames,
-                });
-                break;
-            }
-            if (result.action === "scheduled") {
-                yield result;
-                const r = yield* PROCESS_SCHEDULED_SIGNAL_FN(this, symbol, when, result, previousEventTimestamp);
-                if (r.type === "error") {
+        try {
+            while (i < timeframes.length) {
+                const timeframeStartTime = performance.now();
+                const when = timeframes[i];
+                await EMIT_PROGRESS_FN(this, symbol, totalFrames, i);
+                if (await CHECK_STOPPED_FN(this, symbol, "before tick", { when: when.toISOString(), processedFrames: i, totalFrames })) {
                     break;
                 }
-                if (r.type === "closed") {
-                    previousEventTimestamp = r.previousEventTimestamp;
-                    while (i < timeframes.length && timeframes[i].getTime() < r.closeTimestamp) {
-                        i++;
-                    }
-                    if (r.shouldStop) {
-                        break;
-                    }
+                const result = await TICK_FN(this, symbol, when);
+                if ("__error__" in result) {
+                    _fatalError = new Error(`[${result.reason}] ${result.message}`);
+                    break;
                 }
-            }
-            if (result.action === "opened") {
-                yield result;
-                const r = yield* PROCESS_OPENED_SIGNAL_FN(this, symbol, when, result, previousEventTimestamp);
-                if (r.type === "error") {
+                if (result.action === "idle" &&
+                    await functoolsKit.and(Promise.resolve(true), this.strategyCoreService.getStopped(true, symbol, {
+                        strategyName: this.methodContextService.context.strategyName,
+                        exchangeName: this.methodContextService.context.exchangeName,
+                        frameName: this.methodContextService.context.frameName,
+                    }))) {
+                    this.loggerService.info("backtestLogicPrivateService stopped by user request (idle state)", {
+                        symbol,
+                        when: when.toISOString(),
+                        processedFrames: i,
+                        totalFrames,
+                    });
                     break;
                 }
-                if (r.type === "closed") {
-                    previousEventTimestamp = r.previousEventTimestamp;
-                    while (i < timeframes.length && timeframes[i].getTime() < r.closeTimestamp) {
-                        i++;
+                if (result.action === "scheduled") {
+                    yield result;
+                    const r = yield* PROCESS_SCHEDULED_SIGNAL_FN(this, symbol, when, result, previousEventTimestamp, frameEndTime);
+                    if (r.type === "error") {
+                        _fatalError = new Error(`[${r.reason}] ${r.message}`);
+                        break;
+                    }
+                    if (r.type === "closed") {
+                        previousEventTimestamp = r.previousEventTimestamp;
+                        while (i < timeframes.length && timeframes[i].getTime() < r.closeTimestamp) {
+                            i++;
+                        }
+                        if (r.shouldStop) {
+                            break;
+                        }
                     }
-                    if (r.shouldStop) {
+                }
+                if (result.action === "opened") {
+                    yield result;
+                    const r = yield* PROCESS_OPENED_SIGNAL_FN(this, symbol, when, result, previousEventTimestamp, frameEndTime);
+                    if (r.type === "error") {
+                        _fatalError = new Error(`[${r.reason}] ${r.message}`);
                         break;
                     }
+                    if (r.type === "closed") {
+                        previousEventTimestamp = r.previousEventTimestamp;
+                        while (i < timeframes.length && timeframes[i].getTime() < r.closeTimestamp) {
+                            i++;
+                        }
+                        if (r.shouldStop) {
+                            break;
+                        }
+                    }
                 }
+                previousEventTimestamp = await EMIT_TIMEFRAME_PERFORMANCE_FN(this, symbol, timeframeStartTime, previousEventTimestamp);
+                i++;
             }
-            previousEventTimestamp = await EMIT_TIMEFRAME_PERFORMANCE_FN(this, symbol, timeframeStartTime, previousEventTimestamp);
-            i++;
-        }
-        // Emit final progress event (100%)
-        await EMIT_PROGRESS_FN(this, symbol, totalFrames, totalFrames);
-        // Track total backtest duration
-        const backtestEndTime = performance.now();
-        const currentTimestamp = Date.now();
-        await performanceEmitter.next({
-            timestamp: currentTimestamp,
-            previousTimestamp: previousEventTimestamp,
-            metricType: "backtest_total",
-            duration: backtestEndTime - backtestStartTime,
-            strategyName: this.methodContextService.context.strategyName,
-            exchangeName: this.methodContextService.context.exchangeName,
-            frameName: this.methodContextService.context.frameName,
-            symbol,
-            backtest: true,
-        });
+            // Emit final progress event (100%)
+            await EMIT_PROGRESS_FN(this, symbol, totalFrames, totalFrames);
+            // Track total backtest duration
+            const backtestEndTime = performance.now();
+            const currentTimestamp = Date.now();
+            await performanceEmitter.next({
+                timestamp: currentTimestamp,
+                previousTimestamp: previousEventTimestamp,
+                metricType: "backtest_total",
+                duration: backtestEndTime - backtestStartTime,
+                strategyName: this.methodContextService.context.strategyName,
+                exchangeName: this.methodContextService.context.exchangeName,
+                frameName: this.methodContextService.context.frameName,
+                symbol,
+                backtest: true,
+            });
+        }
+        catch (error) {
+            _fatalError = error;
+        }
+        finally {
+            if (_fatalError !== null) {
+                console.error(`[BacktestLogicPrivateService] Fatal error — backtest sequence broken for symbol=${symbol} ` +
+                    `strategy=${this.methodContextService.context.strategyName}`, _fatalError);
+                process.exit(-1);
+            }
+        }
     }
 }
 
@@ -33344,54 +33379,144 @@ const BROKER_BASE_METHOD_NAME_ON_TRAILING_STOP = "BrokerBase.onTrailingStopCommi
 const BROKER_BASE_METHOD_NAME_ON_TRAILING_TAKE = "BrokerBase.onTrailingTakeCommit";
 const BROKER_BASE_METHOD_NAME_ON_BREAKEVEN = "BrokerBase.onBreakevenCommit";
 const BROKER_BASE_METHOD_NAME_ON_AVERAGE_BUY = "BrokerBase.onAverageBuyCommit";
+/**
+ * Wrapper around a `Partial<IBroker>` adapter instance.
+ *
+ * Implements the full `IBroker` interface but guards every method call —
+ * if the underlying adapter does not implement a given method, an error is thrown.
+ * `waitForInit` is the only exception: it is silently skipped when not implemented.
+ *
+ * Created internally by `BrokerAdapter.useBrokerAdapter` and stored as
+ * `_brokerInstance`. All `BrokerAdapter.commit*` methods delegate here
+ * after backtest-mode and enable-state checks pass.
+ */
 class BrokerProxy {
     constructor(_instance) {
         this._instance = _instance;
+        /**
+         * Calls `waitForInit` on the underlying adapter exactly once (singleshot).
+         * If the adapter does not implement `waitForInit`, the call is silently skipped.
+         *
+         * @returns Resolves when initialization is complete (or immediately if not implemented).
+         */
         this.waitForInit = functoolsKit.singleshot(async () => {
             if (this._instance.waitForInit) {
                 await this._instance.waitForInit();
+                return;
             }
         });
     }
+    /**
+     * Forwards a signal-open event to the underlying adapter.
+     * Throws if the adapter does not implement `onSignalOpenCommit`.
+     *
+     * @param payload - Signal open details: symbol, cost, position, prices, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onSignalOpenCommit`.
+     */
     async onSignalOpenCommit(payload) {
         if (this._instance.onSignalOpenCommit) {
             await this._instance.onSignalOpenCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onSignalOpenCommit is not implemented");
     }
+    /**
+     * Forwards a signal-close event to the underlying adapter.
+     * Throws if the adapter does not implement `onSignalCloseCommit`.
+     *
+     * @param payload - Signal close details: symbol, cost, position, currentPrice, pnl, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onSignalCloseCommit`.
+     */
     async onSignalCloseCommit(payload) {
         if (this._instance.onSignalCloseCommit) {
             await this._instance.onSignalCloseCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onSignalCloseCommit is not implemented");
     }
+    /**
+     * Forwards a partial-profit close event to the underlying adapter.
+     * Throws if the adapter does not implement `onPartialProfitCommit`.
+     *
+     * @param payload - Partial profit details: symbol, percentToClose, cost, currentPrice, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onPartialProfitCommit`.
+     */
     async onPartialProfitCommit(payload) {
         if (this._instance.onPartialProfitCommit) {
             await this._instance.onPartialProfitCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onPartialProfitCommit is not implemented");
     }
+    /**
+     * Forwards a partial-loss close event to the underlying adapter.
+     * Throws if the adapter does not implement `onPartialLossCommit`.
+     *
+     * @param payload - Partial loss details: symbol, percentToClose, cost, currentPrice, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onPartialLossCommit`.
+     */
     async onPartialLossCommit(payload) {
         if (this._instance.onPartialLossCommit) {
             await this._instance.onPartialLossCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onPartialLossCommit is not implemented");
     }
+    /**
+     * Forwards a trailing stop-loss update event to the underlying adapter.
+     * Throws if the adapter does not implement `onTrailingStopCommit`.
+     *
+     * @param payload - Trailing stop details: symbol, percentShift, currentPrice, newStopLossPrice, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onTrailingStopCommit`.
+     */
     async onTrailingStopCommit(payload) {
         if (this._instance.onTrailingStopCommit) {
             await this._instance.onTrailingStopCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onTrailingStopCommit is not implemented");
     }
+    /**
+     * Forwards a trailing take-profit update event to the underlying adapter.
+     * Throws if the adapter does not implement `onTrailingTakeCommit`.
+     *
+     * @param payload - Trailing take details: symbol, percentShift, currentPrice, newTakeProfitPrice, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onTrailingTakeCommit`.
+     */
     async onTrailingTakeCommit(payload) {
         if (this._instance.onTrailingTakeCommit) {
             await this._instance.onTrailingTakeCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onTrailingTakeCommit is not implemented");
     }
+    /**
+     * Forwards a breakeven event to the underlying adapter.
+     * Throws if the adapter does not implement `onBreakevenCommit`.
+     *
+     * @param payload - Breakeven details: symbol, currentPrice, newStopLossPrice (= effectivePriceOpen), newTakeProfitPrice, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onBreakevenCommit`.
+     */
     async onBreakevenCommit(payload) {
         if (this._instance.onBreakevenCommit) {
             await this._instance.onBreakevenCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onBreakevenCommit is not implemented");
     }
+    /**
+     * Forwards a DCA average-buy entry event to the underlying adapter.
+     * Throws if the adapter does not implement `onAverageBuyCommit`.
+     *
+     * @param payload - Average buy details: symbol, currentPrice, cost, context, backtest flag.
+     * @throws {Error} If the adapter does not implement `onAverageBuyCommit`.
+     */
     async onAverageBuyCommit(payload) {
         if (this._instance.onAverageBuyCommit) {
             await this._instance.onAverageBuyCommit(payload);
+            return;
         }
+        throw new Error("BrokerProxy onAverageBuyCommit is not implemented");
     }
 }
 /**
@@ -43163,7 +43288,7 @@ class MemoryLocalInstance {
      * @param value - Value to store and index
      * @param index - Optional BM25 index string; defaults to JSON.stringify(value)
      */
-    async writeMemory(memoryId, value, index) {
+    async writeMemory(memoryId, value, description) {
         bt.loggerService.debug(MEMORY_LOCAL_INSTANCE_METHOD_NAME_WRITE, {
             signalId: this.signalId,
             bucketName: this.bucketName,
@@ -43172,7 +43297,7 @@ class MemoryLocalInstance {
         this._index.upsert({
             id: memoryId,
             content: value,
-            index: index ?? JSON.stringify(value),
+            index: description,
             priority: Date.now(),
         });
     }
@@ -43471,7 +43596,7 @@ class MemoryAdapter {
          * @param dto.value - Value to store
          * @param dto.signalId - Signal identifier
          * @param dto.bucketName - Bucket name
-         * @param dto.index - Optional BM25 index string; defaults to JSON.stringify(value)
+         * @param dto.description - Optional BM25 index string; defaults to JSON.stringify(value)
          */
         this.writeMemory = async (dto) => {
             if (!this.enable.hasValue()) {
@@ -43486,7 +43611,7 @@ class MemoryAdapter {
             const isInitial = !this.getInstance.has(key);
             const instance = this.getInstance(dto.signalId, dto.bucketName);
             await instance.waitForInit(isInitial);
-            return await instance.writeMemory(dto.memoryId, dto.value, dto.index);
+            return await instance.writeMemory(dto.memoryId, dto.value, dto.description);
         };
         /**
          * Search memory using BM25 full-text scoring.
@@ -43637,7 +43762,7 @@ const REMOVE_MEMORY_METHOD_NAME = "memory.removeMemory";
  * ```
  */
 async function writeMemory(dto) {
-    const { bucketName, memoryId, value } = dto;
+    const { bucketName, memoryId, value, description } = dto;
     bt.loggerService.info(WRITE_MEMORY_METHOD_NAME, {
         bucketName,
         memoryId,
@@ -43661,6 +43786,7 @@ async function writeMemory(dto) {
         value,
         signalId: signal.id,
         bucketName,
+        description,
     });
 }
 /**
@@ -44104,7 +44230,7 @@ class DumpMemoryInstance {
             bucketName: this.bucketName,
             signalId: this.signalId,
             value: { messages },
-            index: description,
+            description,
         });
     }
     /**
@@ -44125,7 +44251,7 @@ class DumpMemoryInstance {
             bucketName: this.bucketName,
             signalId: this.signalId,
             value: record,
-            index: description,
+            description,
         });
     }
     /**
@@ -44147,7 +44273,7 @@ class DumpMemoryInstance {
             bucketName: this.bucketName,
             signalId: this.signalId,
             value: { rows },
-            index: description,
+            description,
         });
     }
     /**
@@ -44168,7 +44294,7 @@ class DumpMemoryInstance {
             bucketName: this.bucketName,
             signalId: this.signalId,
             value: { content },
-            index: description,
+            description,
         });
     }
     /**
@@ -44189,7 +44315,7 @@ class DumpMemoryInstance {
             bucketName: this.bucketName,
             signalId: this.signalId,
             value: { content },
-            index: description,
+            description,
         });
     }
     /**
@@ -44211,7 +44337,7 @@ class DumpMemoryInstance {
             bucketName: this.bucketName,
             signalId: this.signalId,
             value: json,
-            index: description,
+            description,
         });
     }
     /** Releases resources held by this instance. */