backtest-kit 2.2.14 → 2.2.15

package/build/index.cjs

@@ -2829,6 +2829,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 = functoolsKit.trycatch(async (self, event) => {
+    await self.params.onCommit(event);
+}, {
+    fallback: (error) => {
+        const message = "ClientStrategy CALL_COMMIT_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.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.
  *
@@ -4775,6 +4883,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,
@@ -4900,6 +5010,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;
 };
@@ -4939,6 +5051,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.
          *
@@ -5186,6 +5300,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);
@@ -5576,6 +5692,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,
@@ -5583,9 +5700,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.
@@ -5615,6 +5758,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,
@@ -5622,9 +5766,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).
@@ -5748,6 +5918,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;
     }
     /**
@@ -5872,6 +6050,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;
     }
     /**
@@ -5987,6 +6173,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;
     }
     /**
@@ -6166,6 +6359,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;
     }
     /**
@@ -6331,6 +6532,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;
     }
 }
@@ -6843,6 +7052,31 @@ const CREATE_COMMIT_INIT_FN = (self) => functoolsKit.trycatch(async (symbol, str
     },
     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) => functoolsKit.trycatch(async (event) => {
+    await strategyCommitSubject.next(event);
+}, {
+    fallback: (error) => {
+        const message = "StrategyConnectionService CREATE_COMMIT_FN thrown";
+        const payload = {
+            error: functoolsKit.errorData(error),
+            message: functoolsKit.getErrorMessage(error),
+        };
+        bt.loggerService.warn(message, payload);
+        console.warn(message, payload);
+        errorEmitter.next(error);
+    },
+    defaultValue: null,
+});
 /**
  * Creates a callback function for emitting dispose events.
  *
@@ -6937,6 +7171,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(),
             });
         });
         /**
@@ -10223,26 +10458,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 = functoolsKit.trycatch(async (event) => {
-    await strategyCommitSubject.next(event);
-}, {
-    fallback: (error) => {
-        const message = "StrategyCoreService CALL_STRATEGY_COMMIT_FN thrown";
-        const payload = {
-            error: functoolsKit.errorData(error),
-            message: functoolsKit.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.
  *
@@ -10475,19 +10690,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.
@@ -10514,19 +10717,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.
@@ -10607,20 +10798,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).
@@ -10661,20 +10839,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.
@@ -10713,20 +10878,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.
@@ -10761,20 +10913,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.
@@ -10804,19 +10943,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);
         };
     }
 }
@@ -23549,22 +23676,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.
  *
@@ -23580,41 +23691,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,
@@ -23623,7 +23716,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,
@@ -23632,10 +23724,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,
@@ -23649,15 +23743,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,
@@ -23666,7 +23758,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,
@@ -23675,10 +23766,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,
@@ -23692,15 +23785,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,
@@ -23710,7 +23802,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,
@@ -23719,11 +23810,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,
@@ -23737,15 +23830,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,
@@ -23755,7 +23847,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,
@@ -23764,11 +23855,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,
@@ -23782,15 +23875,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,
@@ -23800,7 +23892,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,
@@ -23809,11 +23900,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,
@@ -23827,15 +23920,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,
@@ -23845,7 +23937,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,
@@ -23854,11 +23945,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,
@@ -23872,14 +23965,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,
@@ -23888,7 +23980,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,
@@ -23897,10 +23988,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,
@@ -23927,49 +24020,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 = functoolsKit.compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven());
             return () => {
                 disposeFn();
@@ -23991,22 +24084,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.
  *
@@ -24254,7 +24331,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.
@@ -24268,15 +24344,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,
@@ -24285,7 +24359,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,
@@ -24294,9 +24367,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,
@@ -24311,15 +24385,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,
@@ -24328,7 +24400,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,
@@ -24337,9 +24408,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,
@@ -24354,15 +24426,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,
@@ -24372,7 +24443,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,
@@ -24381,9 +24451,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,
@@ -24399,15 +24470,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,
@@ -24417,7 +24487,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,
@@ -24426,9 +24495,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,
@@ -24444,15 +24514,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,
@@ -24462,7 +24531,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,
@@ -24471,9 +24539,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,
@@ -24489,15 +24558,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,
@@ -24507,7 +24575,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,
@@ -24516,9 +24583,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,
@@ -24534,14 +24602,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,
@@ -24550,7 +24617,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,
@@ -24559,9 +24625,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,
@@ -24703,49 +24770,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 = functoolsKit.compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven());
             return () => {
                 disposeFn();
@@ -33114,12 +33181,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.
@@ -33138,6 +33199,7 @@ class NotificationInstance {
                 currentPrice: data.currentPrice,
                 priceOpen: data.data.priceOpen,
                 position: data.data.position,
+                createdAt: data.timestamp,
             });
         };
         /**
@@ -33157,6 +33219,7 @@ class NotificationInstance {
                 currentPrice: data.currentPrice,
                 priceOpen: data.data.priceOpen,
                 position: data.data.position,
+                createdAt: data.timestamp,
             });
         };
         /**
@@ -33175,6 +33238,7 @@ class NotificationInstance {
                 currentPrice: data.currentPrice,
                 priceOpen: data.data.priceOpen,
                 position: data.data.position,
+                createdAt: data.timestamp,
             });
         };
         /**
@@ -33185,64 +33249,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,
                 });
             }
         };
@@ -33263,6 +33332,7 @@ class NotificationInstance {
                 activePositionCount: data.activePositionCount,
                 currentPrice: data.currentPrice,
                 pendingSignal: data.pendingSignal,
+                createdAt: data.timestamp,
             });
         };
         /**
@@ -33272,7 +33342,6 @@ class NotificationInstance {
             this._addNotification({
                 type: "error.info",
                 id: CREATE_KEY_FN(),
-                timestamp: Date.now(),
                 error: functoolsKit.errorData(error),
                 message: functoolsKit.getErrorMessage(error),
                 backtest: false,
@@ -33285,7 +33354,6 @@ class NotificationInstance {
             this._addNotification({
                 type: "error.critical",
                 id: CREATE_KEY_FN(),
-                timestamp: Date.now(),
                 error: functoolsKit.errorData(error),
                 message: functoolsKit.getErrorMessage(error),
                 backtest: false,
@@ -33298,7 +33366,6 @@ class NotificationInstance {
             this._addNotification({
                 type: "error.validation",
                 id: CREATE_KEY_FN(),
-                timestamp: Date.now(),
                 error: functoolsKit.errorData(error),
                 message: functoolsKit.getErrorMessage(error),
                 backtest: false,