backtest-kit 2.2.13 → 2.2.15

package/build/index.mjs

@@ -2809,6 +2809,114 @@ const INTERVAL_MINUTES$3 = {
     "1h": 60,
 };
 const TIMEOUT_SYMBOL = Symbol('timeout');
+/**
+ * Calls onCommit callback with strategy commit event.
+ *
+ * Wraps the callback in trycatch to prevent errors from breaking the flow.
+ * Used by ClientStrategy methods that modify signal state (partial, trailing, breakeven, cancel, close).
+ *
+ * @param self - ClientStrategy instance
+ * @param event - Strategy commit event to emit
+ */
+const CALL_COMMIT_FN = trycatch(async (self, event) => {
+    await self.params.onCommit(event);
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_COMMIT_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+});
+/**
+ * Processes queued commit events with proper execution context timestamp.
+ *
+ * Commit events from partialProfit, partialLoss, breakeven, trailingStop, trailingTake
+ * are queued in _commitQueue and processed here with correct timestamp from
+ * execution context (tick's when or backtest candle timestamp).
+ *
+ * @param self - ClientStrategy instance
+ * @param timestamp - Timestamp from execution context
+ */
+const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
+    if (self._commitQueue.length === 0) {
+        return;
+    }
+    const queue = self._commitQueue;
+    self._commitQueue = [];
+    for (const commit of queue) {
+        switch (commit.action) {
+            case "partial-profit":
+                await CALL_COMMIT_FN(self, {
+                    action: "partial-profit",
+                    symbol: commit.symbol,
+                    strategyName: self.params.strategyName,
+                    exchangeName: self.params.exchangeName,
+                    frameName: self.params.frameName,
+                    backtest: commit.backtest,
+                    percentToClose: commit.percentToClose,
+                    currentPrice: commit.currentPrice,
+                    timestamp,
+                });
+                break;
+            case "partial-loss":
+                await CALL_COMMIT_FN(self, {
+                    action: "partial-loss",
+                    symbol: commit.symbol,
+                    strategyName: self.params.strategyName,
+                    exchangeName: self.params.exchangeName,
+                    frameName: self.params.frameName,
+                    backtest: commit.backtest,
+                    percentToClose: commit.percentToClose,
+                    currentPrice: commit.currentPrice,
+                    timestamp,
+                });
+                break;
+            case "breakeven":
+                await CALL_COMMIT_FN(self, {
+                    action: "breakeven",
+                    symbol: commit.symbol,
+                    strategyName: self.params.strategyName,
+                    exchangeName: self.params.exchangeName,
+                    frameName: self.params.frameName,
+                    backtest: commit.backtest,
+                    currentPrice: commit.currentPrice,
+                    timestamp,
+                });
+                break;
+            case "trailing-stop":
+                await CALL_COMMIT_FN(self, {
+                    action: "trailing-stop",
+                    symbol: commit.symbol,
+                    strategyName: self.params.strategyName,
+                    exchangeName: self.params.exchangeName,
+                    frameName: self.params.frameName,
+                    backtest: commit.backtest,
+                    percentShift: commit.percentShift,
+                    currentPrice: commit.currentPrice,
+                    timestamp,
+                });
+                break;
+            case "trailing-take":
+                await CALL_COMMIT_FN(self, {
+                    action: "trailing-take",
+                    symbol: commit.symbol,
+                    strategyName: self.params.strategyName,
+                    exchangeName: self.params.exchangeName,
+                    frameName: self.params.frameName,
+                    backtest: commit.backtest,
+                    percentShift: commit.percentShift,
+                    currentPrice: commit.currentPrice,
+                    timestamp,
+                });
+                break;
+        }
+    }
+};
 /**
  * Converts internal signal to public API format.
  *
@@ -4755,6 +4863,8 @@ const PROCESS_SCHEDULED_SIGNAL_CANDLES_FN = async (self, scheduled, candles) =>
             };
         }
         await CALL_SCHEDULE_PING_CALLBACKS_FN(self, self.params.execution.context.symbol, scheduled, candle.timestamp, true);
+        // Process queued commit events with candle timestamp
+        await PROCESS_COMMIT_QUEUE_FN(self, candle.timestamp);
     }
     return {
         activated: false,
@@ -4880,6 +4990,8 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                 }
             }
         }
+        // Process queued commit events with candle timestamp
+        await PROCESS_COMMIT_QUEUE_FN(self, currentCandleTimestamp);
     }
     return null;
 };
@@ -4919,6 +5031,8 @@ class ClientStrategy {
         this._scheduledSignal = null;
         this._cancelledSignal = null;
         this._closedSignal = null;
+        /** Queue for commit events to be processed in tick()/backtest() with proper timestamp */
+        this._commitQueue = [];
         /**
          * Initializes strategy state by loading persisted signal from disk.
          *
@@ -5166,6 +5280,8 @@ class ClientStrategy {
         });
         // Получаем текущее время в начале tick для консистентности
         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);
@@ -5556,6 +5672,7 @@ class ClientStrategy {
             cancelId,
         });
         // Save cancelled signal for next tick to emit cancelled event
+        const hadScheduledSignal = this._scheduledSignal !== null;
         if (this._scheduledSignal) {
             this._cancelledSignal = Object.assign({}, this._scheduledSignal, {
                 cancelId,
@@ -5563,9 +5680,35 @@ 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,
+                    backtest,
+                    cancelId,
+                    timestamp: this.params.execution.context.when.getTime(),
+                });
+            }
             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",
+                symbol,
+                strategyName: this.params.strategyName,
+                exchangeName: this.params.exchangeName,
+                frameName: this.params.frameName,
+                backtest,
+                cancelId,
+                timestamp: this.params.execution.context.when.getTime(),
+            });
+        }
     }
     /**
      * Closes the pending signal without stopping the strategy.
@@ -5595,6 +5738,7 @@ class ClientStrategy {
             closeId,
         });
         // Save closed signal for next tick to emit closed event
+        const hadPendingSignal = this._pendingSignal !== null;
         if (this._pendingSignal) {
             this._closedSignal = Object.assign({}, this._pendingSignal, {
                 closeId,
@@ -5602,9 +5746,35 @@ 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,
+                    backtest,
+                    closeId,
+                    timestamp: this.params.execution.context.when.getTime(),
+                });
+            }
             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,
+                backtest,
+                closeId,
+                timestamp: this.params.execution.context.when.getTime(),
+            });
+        }
     }
     /**
      * Executes partial close at profit level (moving toward TP).
@@ -5728,6 +5898,14 @@ class ClientStrategy {
         if (!backtest) {
             await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
         }
+        // Queue commit event for processing in tick()/backtest() with proper timestamp
+        this._commitQueue.push({
+            action: "partial-profit",
+            symbol,
+            backtest,
+            percentToClose,
+            currentPrice,
+        });
         return true;
     }
     /**
@@ -5852,6 +6030,14 @@ class ClientStrategy {
         if (!backtest) {
             await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
         }
+        // Queue commit event for processing in tick()/backtest() with proper timestamp
+        this._commitQueue.push({
+            action: "partial-loss",
+            symbol,
+            backtest,
+            percentToClose,
+            currentPrice,
+        });
         return true;
     }
     /**
@@ -5967,6 +6153,13 @@ class ClientStrategy {
         if (!backtest) {
             await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
         }
+        // Queue commit event for processing in tick()/backtest() with proper timestamp
+        this._commitQueue.push({
+            action: "breakeven",
+            symbol,
+            backtest,
+            currentPrice,
+        });
         return true;
     }
     /**
@@ -6146,6 +6339,14 @@ class ClientStrategy {
         if (!backtest) {
             await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
         }
+        // Queue commit event for processing in tick()/backtest() with proper timestamp
+        this._commitQueue.push({
+            action: "trailing-stop",
+            symbol,
+            backtest,
+            percentShift,
+            currentPrice,
+        });
         return true;
     }
     /**
@@ -6311,6 +6512,14 @@ class ClientStrategy {
         if (!backtest) {
             await PersistSignalAdapter.writeSignalData(this._pendingSignal, this.params.execution.context.symbol, this.params.strategyName, this.params.exchangeName);
         }
+        // Queue commit event for processing in tick()/backtest() with proper timestamp
+        this._commitQueue.push({
+            action: "trailing-take",
+            symbol,
+            backtest,
+            percentShift,
+            currentPrice,
+        });
         return true;
     }
 }
@@ -6823,6 +7032,31 @@ const CREATE_COMMIT_INIT_FN = (self) => trycatch(async (symbol, strategyName, ex
     },
     defaultValue: null,
 });
+/**
+ * Creates a callback function for emitting commit events to strategyCommitSubject.
+ *
+ * Called by ClientStrategy when strategy management actions are executed
+ * (partialProfit, partialLoss, trailingStop, trailingTake, breakeven, cancelScheduled, closePending).
+ * Emits StrategyCommitContract event to all subscribers.
+ *
+ * @param self - Reference to StrategyConnectionService instance
+ * @returns Callback function for commit events
+ */
+const CREATE_COMMIT_FN = (self) => trycatch(async (event) => {
+    await strategyCommitSubject.next(event);
+}, {
+    fallback: (error) => {
+        const message = "StrategyConnectionService CREATE_COMMIT_FN thrown";
+        const payload = {
+            error: errorData(error),
+            message: getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
  * Creates a callback function for emitting dispose events.
  *
@@ -6917,6 +7151,7 @@ class StrategyConnectionService {
                 onSchedulePing: CREATE_COMMIT_SCHEDULE_PING_FN(this),
                 onActivePing: CREATE_COMMIT_ACTIVE_PING_FN(this),
                 onDispose: CREATE_COMMIT_DISPOSE_FN(this),
+                onCommit: CREATE_COMMIT_FN(),
             });
         });
         /**
@@ -10203,26 +10438,6 @@ const CREATE_KEY_FN$h = (context) => {
         parts.push(context.frameName);
     return parts.join(":");
 };
-/**
- * Broadcasts StrategyCommitContract event to strategyCommitSubject.
- *
- * @param event - The signal commit event to broadcast
- */
-const CALL_STRATEGY_COMMIT_FN = trycatch(async (event) => {
-    await strategyCommitSubject.next(event);
-}, {
-    fallback: (error) => {
-        const message = "StrategyCoreService CALL_STRATEGY_COMMIT_FN thrown";
-        const payload = {
-            error: errorData(error),
-            message: getErrorMessage(error),
-        };
-        bt.loggerService.warn(message, payload);
-        console.warn(message, payload);
-        errorEmitter.next(error);
-    },
-    defaultValue: null,
-});
 /**
  * Global service for strategy operations with execution context injection.
  *
@@ -10455,19 +10670,7 @@ class StrategyCoreService {
                 cancelId,
             });
             await this.validate(context);
-            const result = await this.strategyConnectionService.cancelScheduled(backtest, symbol, context, cancelId);
-            {
-                await CALL_STRATEGY_COMMIT_FN({
-                    action: "cancel-scheduled",
-                    symbol,
-                    strategyName: context.strategyName,
-                    exchangeName: context.exchangeName,
-                    frameName: context.frameName,
-                    backtest,
-                    cancelId,
-                });
-            }
-            return result;
+            return await this.strategyConnectionService.cancelScheduled(backtest, symbol, context, cancelId);
         };
         /**
          * Closes the pending signal without stopping the strategy.
@@ -10494,19 +10697,7 @@ class StrategyCoreService {
                 closeId,
             });
             await this.validate(context);
-            const result = await this.strategyConnectionService.closePending(backtest, symbol, context, closeId);
-            {
-                await CALL_STRATEGY_COMMIT_FN({
-                    action: "close-pending",
-                    symbol,
-                    strategyName: context.strategyName,
-                    exchangeName: context.exchangeName,
-                    frameName: context.frameName,
-                    backtest,
-                    closeId,
-                });
-            }
-            return result;
+            return await this.strategyConnectionService.closePending(backtest, symbol, context, closeId);
         };
         /**
          * Disposes the ClientStrategy instance for the given context.
@@ -10587,20 +10778,7 @@ class StrategyCoreService {
                 backtest,
             });
             await this.validate(context);
-            const result = await this.strategyConnectionService.partialProfit(backtest, symbol, percentToClose, currentPrice, context);
-            if (result) {
-                await CALL_STRATEGY_COMMIT_FN({
-                    action: "partial-profit",
-                    symbol,
-                    strategyName: context.strategyName,
-                    exchangeName: context.exchangeName,
-                    frameName: context.frameName,
-                    backtest,
-                    percentToClose,
-                    currentPrice,
-                });
-            }
-            return result;
+            return await this.strategyConnectionService.partialProfit(backtest, symbol, percentToClose, currentPrice, context);
         };
         /**
          * Executes partial close at loss level (moving toward SL).
@@ -10641,20 +10819,7 @@ class StrategyCoreService {
                 backtest,
             });
             await this.validate(context);
-            const result = await this.strategyConnectionService.partialLoss(backtest, symbol, percentToClose, currentPrice, context);
-            if (result) {
-                await CALL_STRATEGY_COMMIT_FN({
-                    action: "partial-loss",
-                    symbol,
-                    strategyName: context.strategyName,
-                    exchangeName: context.exchangeName,
-                    frameName: context.frameName,
-                    backtest,
-                    percentToClose,
-                    currentPrice,
-                });
-            }
-            return result;
+            return await this.strategyConnectionService.partialLoss(backtest, symbol, percentToClose, currentPrice, context);
         };
         /**
          * Adjusts the trailing stop-loss distance for an active pending signal.
@@ -10693,20 +10858,7 @@ class StrategyCoreService {
                 backtest,
             });
             await this.validate(context);
-            const result = await this.strategyConnectionService.trailingStop(backtest, symbol, percentShift, currentPrice, context);
-            if (result) {
-                await CALL_STRATEGY_COMMIT_FN({
-                    action: "trailing-stop",
-                    symbol,
-                    strategyName: context.strategyName,
-                    exchangeName: context.exchangeName,
-                    frameName: context.frameName,
-                    backtest,
-                    percentShift,
-                    currentPrice,
-                });
-            }
-            return result;
+            return await this.strategyConnectionService.trailingStop(backtest, symbol, percentShift, currentPrice, context);
         };
         /**
          * Adjusts the trailing take-profit distance for an active pending signal.
@@ -10741,20 +10893,7 @@ class StrategyCoreService {
                 backtest,
             });
             await this.validate(context);
-            const result = await this.strategyConnectionService.trailingTake(backtest, symbol, percentShift, currentPrice, context);
-            if (result) {
-                await CALL_STRATEGY_COMMIT_FN({
-                    action: "trailing-take",
-                    symbol,
-                    strategyName: context.strategyName,
-                    exchangeName: context.exchangeName,
-                    frameName: context.frameName,
-                    backtest,
-                    percentShift,
-                    currentPrice,
-                });
-            }
-            return result;
+            return await this.strategyConnectionService.trailingTake(backtest, symbol, percentShift, currentPrice, context);
         };
         /**
          * Moves stop-loss to breakeven when price reaches threshold.
@@ -10784,19 +10923,7 @@ class StrategyCoreService {
                 backtest,
             });
             await this.validate(context);
-            const result = await this.strategyConnectionService.breakeven(backtest, symbol, currentPrice, context);
-            if (result) {
-                await CALL_STRATEGY_COMMIT_FN({
-                    action: "breakeven",
-                    symbol,
-                    strategyName: context.strategyName,
-                    exchangeName: context.exchangeName,
-                    frameName: context.frameName,
-                    backtest,
-                    currentPrice,
-                });
-            }
-            return result;
+            return await this.strategyConnectionService.breakeven(backtest, symbol, currentPrice, context);
         };
     }
 }
@@ -23529,22 +23656,6 @@ class RiskReportService {
     }
 }
 
-/**
- * Extracts execution context timestamp for strategy event logging.
- *
- * @param self - The StrategyReportService instance to extract context from
- * @returns Object containing ISO 8601 formatted timestamp, or empty string if no context
- * @internal
- */
-const GET_EXECUTION_CONTEXT_FN$1 = (self) => {
-    if (ExecutionContextService.hasContext()) {
-        const { when } = self.executionContextService.context;
-        return { when: when.toISOString() };
-    }
-    return {
-        when: "",
-    };
-};
 /**
  * Service for persisting strategy management events to JSON report files.
  *
@@ -23560,41 +23671,23 @@ const GET_EXECUTION_CONTEXT_FN$1 = (self) => {
  * - Events are written via Report.writeData() with "strategy" category
  * - Call unsubscribe() to disable event logging
  *
- * @example
- * ```typescript
- * // Service is typically used internally by strategy management classes
- * strategyReportService.subscribe();
- *
- * // Events are logged automatically when strategy actions occur
- * await strategyReportService.partialProfit("BTCUSDT", 50, 50100, false, {
- *   strategyName: "my-strategy",
- *   exchangeName: "binance",
- *   frameName: "1h"
- * });
- *
- * strategyReportService.unsubscribe();
- * ```
- *
  * @see StrategyMarkdownService for in-memory event accumulation and markdown report generation
  * @see Report for the underlying persistence mechanism
  */
 class StrategyReportService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.executionContextService = inject(TYPES.executionContextService);
         this.strategyCoreService = inject(TYPES.strategyCoreService);
         /**
          * Logs a cancel-scheduled event when a scheduled signal is cancelled.
          *
-         * Retrieves the scheduled signal from StrategyCoreService and writes
-         * the cancellation event to the report file.
-         *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @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 cancelId - Optional identifier for the cancellation reason
          */
-        this.cancelScheduled = async (symbol, isBacktest, context, cancelId) => {
+        this.cancelScheduled = async (symbol, isBacktest, context, timestamp, cancelId) => {
             this.loggerService.log("strategyReportService cancelScheduled", {
                 symbol,
                 isBacktest,
@@ -23603,7 +23696,6 @@ class StrategyReportService {
             if (!this.subscribe.hasValue()) {
                 return;
             }
-            const { when: createdAt } = GET_EXECUTION_CONTEXT_FN$1(this);
             const scheduledRow = await this.strategyCoreService.getScheduledSignal(isBacktest, symbol, {
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
@@ -23612,10 +23704,12 @@ class StrategyReportService {
             if (!scheduledRow) {
                 return;
             }
+            const createdAt = new Date(timestamp).toISOString();
             await Report.writeData("strategy", {
                 action: "cancel-scheduled",
                 cancelId,
                 symbol,
+                timestamp,
                 createdAt,
             }, {
                 signalId: scheduledRow.id,
@@ -23629,15 +23723,13 @@ class StrategyReportService {
         /**
          * Logs a close-pending event when a pending signal is closed.
          *
-         * Retrieves the pending signal from StrategyCoreService and writes
-         * the close event to the report file.
-         *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @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 closeId - Optional identifier for the close reason
          */
-        this.closePending = async (symbol, isBacktest, context, closeId) => {
+        this.closePending = async (symbol, isBacktest, context, timestamp, closeId) => {
             this.loggerService.log("strategyReportService closePending", {
                 symbol,
                 isBacktest,
@@ -23646,7 +23738,6 @@ class StrategyReportService {
             if (!this.subscribe.hasValue()) {
                 return;
             }
-            const { when: createdAt } = GET_EXECUTION_CONTEXT_FN$1(this);
             const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
@@ -23655,10 +23746,12 @@ class StrategyReportService {
             if (!pendingRow) {
                 return;
             }
+            const createdAt = new Date(timestamp).toISOString();
             await Report.writeData("strategy", {
                 action: "close-pending",
                 closeId,
                 symbol,
+                timestamp,
                 createdAt,
             }, {
                 signalId: pendingRow.id,
@@ -23672,15 +23765,14 @@ class StrategyReportService {
         /**
          * Logs a partial-profit event when a portion of the position is closed at profit.
          *
-         * Records the percentage closed and current price when partial profit-taking occurs.
-         *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param percentToClose - Percentage of position to close (0-100)
          * @param currentPrice - Current market price at time of partial close
          * @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)
          */
-        this.partialProfit = async (symbol, percentToClose, currentPrice, isBacktest, context) => {
+        this.partialProfit = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp) => {
             this.loggerService.log("strategyReportService partialProfit", {
                 symbol,
                 percentToClose,
@@ -23690,7 +23782,6 @@ class StrategyReportService {
             if (!this.subscribe.hasValue()) {
                 return;
             }
-            const { when: createdAt } = GET_EXECUTION_CONTEXT_FN$1(this);
             const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
@@ -23699,11 +23790,13 @@ class StrategyReportService {
             if (!pendingRow) {
                 return;
             }
+            const createdAt = new Date(timestamp).toISOString();
             await Report.writeData("strategy", {
                 action: "partial-profit",
                 percentToClose,
                 currentPrice,
                 symbol,
+                timestamp,
                 createdAt,
             }, {
                 signalId: pendingRow.id,
@@ -23717,15 +23810,14 @@ class StrategyReportService {
         /**
          * Logs a partial-loss event when a portion of the position is closed at loss.
          *
-         * Records the percentage closed and current price when partial loss-cutting occurs.
-         *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param percentToClose - Percentage of position to close (0-100)
          * @param currentPrice - Current market price at time of partial close
          * @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)
          */
-        this.partialLoss = async (symbol, percentToClose, currentPrice, isBacktest, context) => {
+        this.partialLoss = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp) => {
             this.loggerService.log("strategyReportService partialLoss", {
                 symbol,
                 percentToClose,
@@ -23735,7 +23827,6 @@ class StrategyReportService {
             if (!this.subscribe.hasValue()) {
                 return;
             }
-            const { when: createdAt } = GET_EXECUTION_CONTEXT_FN$1(this);
             const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
@@ -23744,11 +23835,13 @@ class StrategyReportService {
             if (!pendingRow) {
                 return;
             }
+            const createdAt = new Date(timestamp).toISOString();
             await Report.writeData("strategy", {
                 action: "partial-loss",
                 percentToClose,
                 currentPrice,
                 symbol,
+                timestamp,
                 createdAt,
             }, {
                 signalId: pendingRow.id,
@@ -23762,15 +23855,14 @@ class StrategyReportService {
         /**
          * Logs a trailing-stop event when the stop-loss is adjusted.
          *
-         * Records the percentage shift and current price when trailing stop moves.
-         *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param percentShift - Percentage the stop-loss was shifted
          * @param currentPrice - Current market price at time of adjustment
          * @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)
          */
-        this.trailingStop = async (symbol, percentShift, currentPrice, isBacktest, context) => {
+        this.trailingStop = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp) => {
             this.loggerService.log("strategyReportService trailingStop", {
                 symbol,
                 percentShift,
@@ -23780,7 +23872,6 @@ class StrategyReportService {
             if (!this.subscribe.hasValue()) {
                 return;
             }
-            const { when: createdAt } = GET_EXECUTION_CONTEXT_FN$1(this);
             const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
@@ -23789,11 +23880,13 @@ class StrategyReportService {
             if (!pendingRow) {
                 return;
             }
+            const createdAt = new Date(timestamp).toISOString();
             await Report.writeData("strategy", {
                 action: "trailing-stop",
                 percentShift,
                 currentPrice,
                 symbol,
+                timestamp,
                 createdAt,
             }, {
                 signalId: pendingRow.id,
@@ -23807,15 +23900,14 @@ class StrategyReportService {
         /**
          * Logs a trailing-take event when the take-profit is adjusted.
          *
-         * Records the percentage shift and current price when trailing take-profit moves.
-         *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param percentShift - Percentage the take-profit was shifted
          * @param currentPrice - Current market price at time of adjustment
          * @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)
          */
-        this.trailingTake = async (symbol, percentShift, currentPrice, isBacktest, context) => {
+        this.trailingTake = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp) => {
             this.loggerService.log("strategyReportService trailingTake", {
                 symbol,
                 percentShift,
@@ -23825,7 +23917,6 @@ class StrategyReportService {
             if (!this.subscribe.hasValue()) {
                 return;
             }
-            const { when: createdAt } = GET_EXECUTION_CONTEXT_FN$1(this);
             const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
@@ -23834,11 +23925,13 @@ class StrategyReportService {
             if (!pendingRow) {
                 return;
             }
+            const createdAt = new Date(timestamp).toISOString();
             await Report.writeData("strategy", {
                 action: "trailing-take",
                 percentShift,
                 currentPrice,
                 symbol,
+                timestamp,
                 createdAt,
             }, {
                 signalId: pendingRow.id,
@@ -23852,14 +23945,13 @@ class StrategyReportService {
         /**
          * Logs a breakeven event when the stop-loss is moved to entry price.
          *
-         * Records the current price when breakeven protection is activated.
-         *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param currentPrice - Current market price at time of breakeven 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)
          */
-        this.breakeven = async (symbol, currentPrice, isBacktest, context) => {
+        this.breakeven = async (symbol, currentPrice, isBacktest, context, timestamp) => {
             this.loggerService.log("strategyReportService breakeven", {
                 symbol,
                 currentPrice,
@@ -23868,7 +23960,6 @@ class StrategyReportService {
             if (!this.subscribe.hasValue()) {
                 return;
             }
-            const { when: createdAt } = GET_EXECUTION_CONTEXT_FN$1(this);
             const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
@@ -23877,10 +23968,12 @@ class StrategyReportService {
             if (!pendingRow) {
                 return;
             }
+            const createdAt = new Date(timestamp).toISOString();
             await Report.writeData("strategy", {
                 action: "breakeven",
                 currentPrice,
                 symbol,
+                timestamp,
                 createdAt,
             }, {
                 signalId: pendingRow.id,
@@ -23907,49 +24000,49 @@ class StrategyReportService {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.cancelId));
+            }, event.timestamp, event.cancelId));
             const unClosePending = strategyCommitSubject
                 .filter(({ action }) => action === "close-pending")
                 .connect(async (event) => await this.closePending(event.symbol, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.closeId));
+            }, event.timestamp, event.closeId));
             const unPartialProfit = strategyCommitSubject
                 .filter(({ action }) => action === "partial-profit")
                 .connect(async (event) => await this.partialProfit(event.symbol, event.percentToClose, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }));
+            }, event.timestamp));
             const unPartialLoss = strategyCommitSubject
                 .filter(({ action }) => action === "partial-loss")
                 .connect(async (event) => await this.partialLoss(event.symbol, event.percentToClose, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }));
+            }, event.timestamp));
             const unTrailingStop = strategyCommitSubject
                 .filter(({ action }) => action === "trailing-stop")
                 .connect(async (event) => await this.trailingStop(event.symbol, event.percentShift, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }));
+            }, event.timestamp));
             const unTrailingTake = strategyCommitSubject
                 .filter(({ action }) => action === "trailing-take")
                 .connect(async (event) => await this.trailingTake(event.symbol, event.percentShift, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }));
+            }, event.timestamp));
             const unBreakeven = strategyCommitSubject
                 .filter(({ action }) => action === "breakeven")
                 .connect(async (event) => await this.breakeven(event.symbol, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }));
+            }, event.timestamp));
             const disposeFn = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven());
             return () => {
                 disposeFn();
@@ -23971,22 +24064,6 @@ class StrategyReportService {
     }
 }
 
-/**
- * Extracts execution context timestamp for strategy event logging.
- *
- * @param self - The StrategyMarkdownService instance to extract context from
- * @returns Object containing ISO 8601 formatted timestamp, or empty string if no context
- * @internal
- */
-const GET_EXECUTION_CONTEXT_FN = (self) => {
-    if (ExecutionContextService.hasContext()) {
-        const { when } = self.executionContextService.context;
-        return { when: when.toISOString() };
-    }
-    return {
-        when: "",
-    };
-};
 /**
  * Creates a unique key for memoizing ReportStorage instances.
  *
@@ -24234,7 +24311,6 @@ class ReportStorage {
 class StrategyMarkdownService {
     constructor() {
         this.loggerService = inject(TYPES.loggerService);
-        this.executionContextService = inject(TYPES.executionContextService);
         this.strategyCoreService = inject(TYPES.strategyCoreService);
         /**
          * Memoized factory for ReportStorage instances.
@@ -24248,15 +24324,13 @@ class StrategyMarkdownService {
         /**
          * Records a cancel-scheduled event when a scheduled signal is cancelled.
          *
-         * Retrieves the scheduled signal from StrategyCoreService and stores
-         * the cancellation event in the appropriate ReportStorage.
-         *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @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 cancelId - Optional identifier for the cancellation reason
          */
-        this.cancelScheduled = async (symbol, isBacktest, context, cancelId) => {
+        this.cancelScheduled = async (symbol, isBacktest, context, timestamp, cancelId) => {
             this.loggerService.log("strategyMarkdownService cancelScheduled", {
                 symbol,
                 isBacktest,
@@ -24265,7 +24339,6 @@ class StrategyMarkdownService {
             if (!this.subscribe.hasValue()) {
                 return;
             }
-            const { when: createdAt } = GET_EXECUTION_CONTEXT_FN(this);
             const scheduledRow = await this.strategyCoreService.getScheduledSignal(isBacktest, symbol, {
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
@@ -24274,9 +24347,10 @@ class StrategyMarkdownService {
             if (!scheduledRow) {
                 return;
             }
+            const createdAt = new Date(timestamp).toISOString();
             const storage = this.getStorage(symbol, context.strategyName, context.exchangeName, context.frameName, isBacktest);
             storage.addEvent({
-                timestamp: Date.now(),
+                timestamp,
                 symbol,
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -24291,15 +24365,13 @@ class StrategyMarkdownService {
         /**
          * Records a close-pending event when a pending signal is closed.
          *
-         * Retrieves the pending signal from StrategyCoreService and stores
-         * the close event in the appropriate ReportStorage.
-         *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @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 closeId - Optional identifier for the close reason
          */
-        this.closePending = async (symbol, isBacktest, context, closeId) => {
+        this.closePending = async (symbol, isBacktest, context, timestamp, closeId) => {
             this.loggerService.log("strategyMarkdownService closePending", {
                 symbol,
                 isBacktest,
@@ -24308,7 +24380,6 @@ class StrategyMarkdownService {
             if (!this.subscribe.hasValue()) {
                 return;
             }
-            const { when: createdAt } = GET_EXECUTION_CONTEXT_FN(this);
             const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
@@ -24317,9 +24388,10 @@ class StrategyMarkdownService {
             if (!pendingRow) {
                 return;
             }
+            const createdAt = new Date(timestamp).toISOString();
             const storage = this.getStorage(symbol, context.strategyName, context.exchangeName, context.frameName, isBacktest);
             storage.addEvent({
-                timestamp: Date.now(),
+                timestamp,
                 symbol,
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -24334,15 +24406,14 @@ class StrategyMarkdownService {
         /**
          * Records a partial-profit event when a portion of the position is closed at profit.
          *
-         * Stores the percentage closed and current price when partial profit-taking occurs.
-         *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param percentToClose - Percentage of position to close (0-100)
          * @param currentPrice - Current market price at time of partial close
          * @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)
          */
-        this.partialProfit = async (symbol, percentToClose, currentPrice, isBacktest, context) => {
+        this.partialProfit = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp) => {
             this.loggerService.log("strategyMarkdownService partialProfit", {
                 symbol,
                 percentToClose,
@@ -24352,7 +24423,6 @@ class StrategyMarkdownService {
             if (!this.subscribe.hasValue()) {
                 return;
             }
-            const { when: createdAt } = GET_EXECUTION_CONTEXT_FN(this);
             const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
@@ -24361,9 +24431,10 @@ class StrategyMarkdownService {
             if (!pendingRow) {
                 return;
             }
+            const createdAt = new Date(timestamp).toISOString();
             const storage = this.getStorage(symbol, context.strategyName, context.exchangeName, context.frameName, isBacktest);
             storage.addEvent({
-                timestamp: Date.now(),
+                timestamp,
                 symbol,
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -24379,15 +24450,14 @@ class StrategyMarkdownService {
         /**
          * Records a partial-loss event when a portion of the position is closed at loss.
          *
-         * Stores the percentage closed and current price when partial loss-cutting occurs.
-         *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param percentToClose - Percentage of position to close (0-100)
          * @param currentPrice - Current market price at time of partial close
          * @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)
          */
-        this.partialLoss = async (symbol, percentToClose, currentPrice, isBacktest, context) => {
+        this.partialLoss = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp) => {
             this.loggerService.log("strategyMarkdownService partialLoss", {
                 symbol,
                 percentToClose,
@@ -24397,7 +24467,6 @@ class StrategyMarkdownService {
             if (!this.subscribe.hasValue()) {
                 return;
             }
-            const { when: createdAt } = GET_EXECUTION_CONTEXT_FN(this);
             const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
@@ -24406,9 +24475,10 @@ class StrategyMarkdownService {
             if (!pendingRow) {
                 return;
             }
+            const createdAt = new Date(timestamp).toISOString();
             const storage = this.getStorage(symbol, context.strategyName, context.exchangeName, context.frameName, isBacktest);
             storage.addEvent({
-                timestamp: Date.now(),
+                timestamp,
                 symbol,
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -24424,15 +24494,14 @@ class StrategyMarkdownService {
         /**
          * Records a trailing-stop event when the stop-loss is adjusted.
          *
-         * Stores the percentage shift and current price when trailing stop moves.
-         *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param percentShift - Percentage the stop-loss was shifted
          * @param currentPrice - Current market price at time of adjustment
          * @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)
          */
-        this.trailingStop = async (symbol, percentShift, currentPrice, isBacktest, context) => {
+        this.trailingStop = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp) => {
             this.loggerService.log("strategyMarkdownService trailingStop", {
                 symbol,
                 percentShift,
@@ -24442,7 +24511,6 @@ class StrategyMarkdownService {
             if (!this.subscribe.hasValue()) {
                 return;
             }
-            const { when: createdAt } = GET_EXECUTION_CONTEXT_FN(this);
             const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
@@ -24451,9 +24519,10 @@ class StrategyMarkdownService {
             if (!pendingRow) {
                 return;
             }
+            const createdAt = new Date(timestamp).toISOString();
             const storage = this.getStorage(symbol, context.strategyName, context.exchangeName, context.frameName, isBacktest);
             storage.addEvent({
-                timestamp: Date.now(),
+                timestamp,
                 symbol,
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -24469,15 +24538,14 @@ class StrategyMarkdownService {
         /**
          * Records a trailing-take event when the take-profit is adjusted.
          *
-         * Stores the percentage shift and current price when trailing take-profit moves.
-         *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param percentShift - Percentage the take-profit was shifted
          * @param currentPrice - Current market price at time of adjustment
          * @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)
          */
-        this.trailingTake = async (symbol, percentShift, currentPrice, isBacktest, context) => {
+        this.trailingTake = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp) => {
             this.loggerService.log("strategyMarkdownService trailingTake", {
                 symbol,
                 percentShift,
@@ -24487,7 +24555,6 @@ class StrategyMarkdownService {
             if (!this.subscribe.hasValue()) {
                 return;
             }
-            const { when: createdAt } = GET_EXECUTION_CONTEXT_FN(this);
             const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
@@ -24496,9 +24563,10 @@ class StrategyMarkdownService {
             if (!pendingRow) {
                 return;
             }
+            const createdAt = new Date(timestamp).toISOString();
             const storage = this.getStorage(symbol, context.strategyName, context.exchangeName, context.frameName, isBacktest);
             storage.addEvent({
-                timestamp: Date.now(),
+                timestamp,
                 symbol,
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -24514,14 +24582,13 @@ class StrategyMarkdownService {
         /**
          * Records a breakeven event when the stop-loss is moved to entry price.
          *
-         * Stores the current price when breakeven protection is activated.
-         *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param currentPrice - Current market price at time of breakeven 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)
          */
-        this.breakeven = async (symbol, currentPrice, isBacktest, context) => {
+        this.breakeven = async (symbol, currentPrice, isBacktest, context, timestamp) => {
             this.loggerService.log("strategyMarkdownService breakeven", {
                 symbol,
                 currentPrice,
@@ -24530,7 +24597,6 @@ class StrategyMarkdownService {
             if (!this.subscribe.hasValue()) {
                 return;
             }
-            const { when: createdAt } = GET_EXECUTION_CONTEXT_FN(this);
             const pendingRow = await this.strategyCoreService.getPendingSignal(isBacktest, symbol, {
                 exchangeName: context.exchangeName,
                 strategyName: context.strategyName,
@@ -24539,9 +24605,10 @@ class StrategyMarkdownService {
             if (!pendingRow) {
                 return;
             }
+            const createdAt = new Date(timestamp).toISOString();
             const storage = this.getStorage(symbol, context.strategyName, context.exchangeName, context.frameName, isBacktest);
             storage.addEvent({
-                timestamp: Date.now(),
+                timestamp,
                 symbol,
                 strategyName: context.strategyName,
                 exchangeName: context.exchangeName,
@@ -24683,49 +24750,49 @@ class StrategyMarkdownService {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.cancelId));
+            }, event.timestamp, event.cancelId));
             const unClosePending = strategyCommitSubject
                 .filter(({ action }) => action === "close-pending")
                 .connect(async (event) => await this.closePending(event.symbol, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.closeId));
+            }, event.timestamp, event.closeId));
             const unPartialProfit = strategyCommitSubject
                 .filter(({ action }) => action === "partial-profit")
                 .connect(async (event) => await this.partialProfit(event.symbol, event.percentToClose, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }));
+            }, event.timestamp));
             const unPartialLoss = strategyCommitSubject
                 .filter(({ action }) => action === "partial-loss")
                 .connect(async (event) => await this.partialLoss(event.symbol, event.percentToClose, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }));
+            }, event.timestamp));
             const unTrailingStop = strategyCommitSubject
                 .filter(({ action }) => action === "trailing-stop")
                 .connect(async (event) => await this.trailingStop(event.symbol, event.percentShift, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }));
+            }, event.timestamp));
             const unTrailingTake = strategyCommitSubject
                 .filter(({ action }) => action === "trailing-take")
                 .connect(async (event) => await this.trailingTake(event.symbol, event.percentShift, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }));
+            }, event.timestamp));
             const unBreakeven = strategyCommitSubject
                 .filter(({ action }) => action === "breakeven")
                 .connect(async (event) => await this.breakeven(event.symbol, event.currentPrice, event.backtest, {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }));
+            }, event.timestamp));
             const disposeFn = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven());
             return () => {
                 disposeFn();
@@ -31605,6 +31672,7 @@ class StorageBacktestUtils {
                 ...tick.signal,
                 status: "opened",
                 priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
                 updatedAt: tick.createdAt,
             });
             await this._updateStorage();
@@ -31628,6 +31696,7 @@ class StorageBacktestUtils {
                 ...tick.signal,
                 status: "closed",
                 priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
                 updatedAt: tick.createdAt,
             });
             await this._updateStorage();
@@ -31651,6 +31720,7 @@ class StorageBacktestUtils {
                 ...tick.signal,
                 status: "scheduled",
                 priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
                 updatedAt: tick.createdAt,
             });
             await this._updateStorage();
@@ -31674,6 +31744,7 @@ class StorageBacktestUtils {
                 ...tick.signal,
                 status: "cancelled",
                 priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
                 updatedAt: tick.createdAt,
             });
             await this._updateStorage();
@@ -31770,6 +31841,7 @@ class StorageLiveUtils {
                 ...tick.signal,
                 status: "opened",
                 priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
                 updatedAt: tick.createdAt,
             });
             await this._updateStorage();
@@ -31793,6 +31865,7 @@ class StorageLiveUtils {
                 ...tick.signal,
                 status: "closed",
                 priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
                 updatedAt: tick.createdAt,
             });
             await this._updateStorage();
@@ -31816,6 +31889,7 @@ class StorageLiveUtils {
                 ...tick.signal,
                 status: "scheduled",
                 priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
                 updatedAt: tick.createdAt,
             });
             await this._updateStorage();
@@ -31839,6 +31913,7 @@ class StorageLiveUtils {
                 ...tick.signal,
                 status: "cancelled",
                 priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
                 updatedAt: tick.createdAt,
             });
             await this._updateStorage();
@@ -33086,12 +33161,6 @@ class NotificationInstance {
                     createdAt: data.createdAt,
                 });
             }
-            // Sort signal notifications by createdAt (newest first)
-            this._notifications.sort((a, b) => {
-                const aCreatedAt = "createdAt" in a ? a.createdAt : 0;
-                const bCreatedAt = "createdAt" in b ? b.createdAt : 0;
-                return bCreatedAt - aCreatedAt;
-            });
         };
         /**
          * Processes partial profit events.
@@ -33110,6 +33179,7 @@ class NotificationInstance {
                 currentPrice: data.currentPrice,
                 priceOpen: data.data.priceOpen,
                 position: data.data.position,
+                createdAt: data.timestamp,
             });
         };
         /**
@@ -33129,6 +33199,7 @@ class NotificationInstance {
                 currentPrice: data.currentPrice,
                 priceOpen: data.data.priceOpen,
                 position: data.data.position,
+                createdAt: data.timestamp,
             });
         };
         /**
@@ -33147,6 +33218,7 @@ class NotificationInstance {
                 currentPrice: data.currentPrice,
                 priceOpen: data.data.priceOpen,
                 position: data.data.position,
+                createdAt: data.timestamp,
             });
         };
         /**
@@ -33157,64 +33229,69 @@ class NotificationInstance {
                 this._addNotification({
                     type: "partial_profit.commit",
                     id: CREATE_KEY_FN(),
-                    timestamp: Date.now(),
+                    timestamp: data.timestamp,
                     backtest: data.backtest,
                     symbol: data.symbol,
                     strategyName: data.strategyName,
                     exchangeName: data.exchangeName,
                     percentToClose: data.percentToClose,
                     currentPrice: data.currentPrice,
+                    createdAt: data.timestamp,
                 });
             }
             else if (data.action === "partial-loss") {
                 this._addNotification({
                     type: "partial_loss.commit",
                     id: CREATE_KEY_FN(),
-                    timestamp: Date.now(),
+                    timestamp: data.timestamp,
                     backtest: data.backtest,
                     symbol: data.symbol,
                     strategyName: data.strategyName,
                     exchangeName: data.exchangeName,
                     percentToClose: data.percentToClose,
                     currentPrice: data.currentPrice,
+                    createdAt: data.timestamp,
                 });
             }
             else if (data.action === "breakeven") {
                 this._addNotification({
                     type: "breakeven.commit",
                     id: CREATE_KEY_FN(),
-                    timestamp: Date.now(),
+                    timestamp: data.timestamp,
                     backtest: data.backtest,
                     symbol: data.symbol,
                     strategyName: data.strategyName,
                     exchangeName: data.exchangeName,
                     currentPrice: data.currentPrice,
+                    createdAt: data.timestamp,
                 });
             }
             else if (data.action === "trailing-stop") {
                 this._addNotification({
                     type: "trailing_stop.commit",
                     id: CREATE_KEY_FN(),
-                    timestamp: Date.now(),
+                    timestamp: data.timestamp,
                     backtest: data.backtest,
                     symbol: data.symbol,
                     strategyName: data.strategyName,
                     exchangeName: data.exchangeName,
                     percentShift: data.percentShift,
                     currentPrice: data.currentPrice,
+                    createdAt: data.timestamp,
                 });
             }
             else if (data.action === "trailing-take") {
                 this._addNotification({
                     type: "trailing_take.commit",
                     id: CREATE_KEY_FN(),
-                    timestamp: Date.now(),
+                    timestamp: data.timestamp,
                     backtest: data.backtest,
                     symbol: data.symbol,
                     strategyName: data.strategyName,
                     exchangeName: data.exchangeName,
                     percentShift: data.percentShift,
                     currentPrice: data.currentPrice,
+                    createdAt: data.timestamp,
                 });
             }
         };
@@ -33235,6 +33312,7 @@ class NotificationInstance {
                 activePositionCount: data.activePositionCount,
                 currentPrice: data.currentPrice,
                 pendingSignal: data.pendingSignal,
+                createdAt: data.timestamp,
             });
         };
         /**
@@ -33244,7 +33322,6 @@ class NotificationInstance {
             this._addNotification({
                 type: "error.info",
                 id: CREATE_KEY_FN(),
-                timestamp: Date.now(),
                 error: errorData(error),
                 message: getErrorMessage(error),
                 backtest: false,
@@ -33257,7 +33334,6 @@ class NotificationInstance {
             this._addNotification({
                 type: "error.critical",
                 id: CREATE_KEY_FN(),
-                timestamp: Date.now(),
                 error: errorData(error),
                 message: getErrorMessage(error),
                 backtest: false,
@@ -33270,7 +33346,6 @@ class NotificationInstance {
             this._addNotification({
                 type: "error.validation",
                 id: CREATE_KEY_FN(),
-                timestamp: Date.now(),
                 error: errorData(error),
                 message: getErrorMessage(error),
                 backtest: false,