backtest-kit 2.2.17 → 2.2.19

package/build/index.cjs

@@ -2828,6 +2828,11 @@ const INTERVAL_MINUTES$3 = {
     "30m": 30,
     "1h": 60,
 };
+/**
+ * Mock value for scheduled signal pendingAt timestamp.
+ * Used to indicate that the actual pendingAt will be set upon activation.
+ */
+const SCHEDULED_SIGNAL_PENDING_MOCK = 0;
 const TIMEOUT_SYMBOL = Symbol('timeout');
 /**
  * Calls onCommit callback with strategy commit event.
@@ -2867,73 +2872,123 @@ const PROCESS_COMMIT_QUEUE_FN = async (self, timestamp) => {
         return;
     }
     const queue = self._commitQueue;
-    self._commitQueue = [];
+    {
+        self._commitQueue = [];
+    }
+    if (!self._pendingSignal) {
+        return;
+    }
+    // Get public signal data for commit events (contains effective and original SL/TP)
+    const publicSignal = TO_PUBLIC_SIGNAL(self._pendingSignal);
     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;
+        if (commit.action === "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,
+                position: publicSignal.position,
+                priceOpen: publicSignal.priceOpen,
+                priceTakeProfit: publicSignal.priceTakeProfit,
+                priceStopLoss: publicSignal.priceStopLoss,
+                originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
+                originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                scheduledAt: publicSignal.scheduledAt,
+                pendingAt: publicSignal.pendingAt,
+            });
+            continue;
+        }
+        if (commit.action === "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,
+                position: publicSignal.position,
+                priceOpen: publicSignal.priceOpen,
+                priceTakeProfit: publicSignal.priceTakeProfit,
+                priceStopLoss: publicSignal.priceStopLoss,
+                originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
+                originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                scheduledAt: publicSignal.scheduledAt,
+                pendingAt: publicSignal.pendingAt,
+            });
+            continue;
+        }
+        if (commit.action === "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,
+                position: publicSignal.position,
+                priceOpen: publicSignal.priceOpen,
+                priceTakeProfit: publicSignal.priceTakeProfit,
+                priceStopLoss: publicSignal.priceStopLoss,
+                originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
+                originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                scheduledAt: publicSignal.scheduledAt,
+                pendingAt: publicSignal.pendingAt,
+            });
+            continue;
+        }
+        if (commit.action === "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,
+                position: publicSignal.position,
+                priceOpen: publicSignal.priceOpen,
+                priceTakeProfit: publicSignal.priceTakeProfit,
+                priceStopLoss: publicSignal.priceStopLoss,
+                originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
+                originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                scheduledAt: publicSignal.scheduledAt,
+                pendingAt: publicSignal.pendingAt,
+            });
+            continue;
+        }
+        if (commit.action === "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,
+                position: publicSignal.position,
+                priceOpen: publicSignal.priceOpen,
+                priceTakeProfit: publicSignal.priceTakeProfit,
+                priceStopLoss: publicSignal.priceStopLoss,
+                originalPriceTakeProfit: publicSignal.originalPriceTakeProfit,
+                originalPriceStopLoss: publicSignal.originalPriceStopLoss,
+                scheduledAt: publicSignal.scheduledAt,
+                pendingAt: publicSignal.pendingAt,
+            });
+            continue;
         }
     }
 };
@@ -3258,7 +3313,7 @@ const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
         if (typeof signal.pendingAt !== "number") {
             errors.push(`pendingAt must be a number type, got ${signal.pendingAt} (${typeof signal.pendingAt})`);
         }
-        if (signal.pendingAt <= 0) {
+        if (signal.pendingAt <= 0 && !isScheduled) {
             errors.push(`pendingAt must be positive, got ${signal.pendingAt}`);
         }
     }
@@ -3344,7 +3399,7 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
             strategyName: self.params.method.context.strategyName,
             frameName: self.params.method.context.frameName,
             scheduledAt: currentTime,
-            pendingAt: currentTime, // Временно, обновится при активации
+            pendingAt: SCHEDULED_SIGNAL_PENDING_MOCK, // Временно, обновится при активации
             _isScheduled: true,
         };
         // Валидируем сигнал перед возвратом
@@ -13488,6 +13543,8 @@ const backtest_columns = [
         key: "duration",
         label: "Duration (min)",
         format: (data) => {
+            if (!data.closeTimestamp || !data.signal.pendingAt)
+                return "N/A";
             const durationMs = data.closeTimestamp - data.signal.pendingAt;
             const durationMin = Math.round(durationMs / 60000);
             return `${durationMin}`;
@@ -13497,7 +13554,7 @@ const backtest_columns = [
     {
         key: "openTimestamp",
         label: "Open Time",
-        format: (data) => new Date(data.signal.pendingAt).toISOString(),
+        format: (data) => data.signal.pendingAt ? new Date(data.signal.pendingAt).toISOString() : "N/A",
         isVisible: () => true,
     },
     {
@@ -23626,7 +23683,7 @@ class RiskReportService {
                 strategyName: data.strategyName,
                 exchangeName: data.exchangeName,
                 frameName: data.frameName,
-                signalId: "",
+                signalId: data.pendingSignal?.id || "",
                 walkerName: "",
             });
         };
@@ -23791,8 +23848,16 @@ class StrategyReportService {
          * @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, timestamp) => {
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Entry price for the position
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         */
+        this.partialProfit = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
             this.loggerService.log("strategyReportService partialProfit", {
                 symbol,
                 percentToClose,
@@ -23818,6 +23883,14 @@ class StrategyReportService {
                 symbol,
                 timestamp,
                 createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             }, {
                 signalId: pendingRow.id,
                 exchangeName: context.exchangeName,
@@ -23836,8 +23909,16 @@ class StrategyReportService {
          * @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, timestamp) => {
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Entry price for the position
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         */
+        this.partialLoss = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
             this.loggerService.log("strategyReportService partialLoss", {
                 symbol,
                 percentToClose,
@@ -23863,6 +23944,14 @@ class StrategyReportService {
                 symbol,
                 timestamp,
                 createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             }, {
                 signalId: pendingRow.id,
                 exchangeName: context.exchangeName,
@@ -23881,8 +23970,16 @@ class StrategyReportService {
          * @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, timestamp) => {
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Entry price for the position
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         */
+        this.trailingStop = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
             this.loggerService.log("strategyReportService trailingStop", {
                 symbol,
                 percentShift,
@@ -23908,6 +24005,14 @@ class StrategyReportService {
                 symbol,
                 timestamp,
                 createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             }, {
                 signalId: pendingRow.id,
                 exchangeName: context.exchangeName,
@@ -23926,8 +24031,16 @@ class StrategyReportService {
          * @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, timestamp) => {
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Entry price for the position
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         */
+        this.trailingTake = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
             this.loggerService.log("strategyReportService trailingTake", {
                 symbol,
                 percentShift,
@@ -23953,6 +24066,14 @@ class StrategyReportService {
                 symbol,
                 timestamp,
                 createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             }, {
                 signalId: pendingRow.id,
                 exchangeName: context.exchangeName,
@@ -23970,8 +24091,16 @@ class StrategyReportService {
          * @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, timestamp) => {
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Entry price for the position
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         */
+        this.breakeven = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
             this.loggerService.log("strategyReportService breakeven", {
                 symbol,
                 currentPrice,
@@ -23995,6 +24124,14 @@ class StrategyReportService {
                 symbol,
                 timestamp,
                 createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             }, {
                 signalId: pendingRow.id,
                 exchangeName: context.exchangeName,
@@ -24034,35 +24171,35 @@ class StrategyReportService {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
             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));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
             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));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
             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));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
             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));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
             const disposeFn = functoolsKit.compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven());
             return () => {
                 disposeFn();
@@ -24432,8 +24569,16 @@ class StrategyMarkdownService {
          * @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, timestamp) => {
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Entry price for the position
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         */
+        this.partialProfit = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
             this.loggerService.log("strategyMarkdownService partialProfit", {
                 symbol,
                 percentToClose,
@@ -24465,6 +24610,14 @@ class StrategyMarkdownService {
                 currentPrice,
                 createdAt,
                 backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             });
         };
         /**
@@ -24476,8 +24629,16 @@ class StrategyMarkdownService {
          * @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, timestamp) => {
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Entry price for the position
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         */
+        this.partialLoss = async (symbol, percentToClose, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
             this.loggerService.log("strategyMarkdownService partialLoss", {
                 symbol,
                 percentToClose,
@@ -24509,6 +24670,14 @@ class StrategyMarkdownService {
                 currentPrice,
                 createdAt,
                 backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             });
         };
         /**
@@ -24520,8 +24689,16 @@ class StrategyMarkdownService {
          * @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, timestamp) => {
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Entry price for the position
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         */
+        this.trailingStop = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
             this.loggerService.log("strategyMarkdownService trailingStop", {
                 symbol,
                 percentShift,
@@ -24553,6 +24730,14 @@ class StrategyMarkdownService {
                 currentPrice,
                 createdAt,
                 backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             });
         };
         /**
@@ -24564,8 +24749,16 @@ class StrategyMarkdownService {
          * @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, timestamp) => {
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Entry price for the position
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         */
+        this.trailingTake = async (symbol, percentShift, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
             this.loggerService.log("strategyMarkdownService trailingTake", {
                 symbol,
                 percentShift,
@@ -24597,6 +24790,14 @@ class StrategyMarkdownService {
                 currentPrice,
                 createdAt,
                 backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             });
         };
         /**
@@ -24607,8 +24808,16 @@ class StrategyMarkdownService {
          * @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, timestamp) => {
+         * @param position - Trade direction: "long" or "short"
+         * @param priceOpen - Entry price for the position
+         * @param priceTakeProfit - Effective take profit price
+         * @param priceStopLoss - Effective stop loss price
+         * @param originalPriceTakeProfit - Original take profit before trailing
+         * @param originalPriceStopLoss - Original stop loss before trailing
+         * @param scheduledAt - Signal creation timestamp in milliseconds
+         * @param pendingAt - Pending timestamp in milliseconds
+         */
+        this.breakeven = async (symbol, currentPrice, isBacktest, context, timestamp, position, priceOpen, priceTakeProfit, priceStopLoss, originalPriceTakeProfit, originalPriceStopLoss, scheduledAt, pendingAt) => {
             this.loggerService.log("strategyMarkdownService breakeven", {
                 symbol,
                 currentPrice,
@@ -24638,6 +24847,14 @@ class StrategyMarkdownService {
                 currentPrice,
                 createdAt,
                 backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             });
         };
         /**
@@ -24784,35 +25001,35 @@ class StrategyMarkdownService {
                 exchangeName: event.exchangeName,
                 frameName: event.frameName,
                 strategyName: event.strategyName,
-            }, event.timestamp));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
             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));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
             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));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
             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));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
             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));
+            }, event.timestamp, event.position, event.priceOpen, event.priceTakeProfit, event.priceStopLoss, event.originalPriceTakeProfit, event.originalPriceStopLoss, event.scheduledAt, event.pendingAt));
             const disposeFn = functoolsKit.compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven());
             return () => {
                 disposeFn();
@@ -31617,53 +31834,64 @@ class ConstantUtils {
 const Constant = new ConstantUtils();
 
 const MAX_SIGNALS = 25;
-const STORAGE_BACKTEST_METHOD_NAME_WAIT_FOR_INIT = "StorageBacktestUtils.waitForInit";
-const STORAGE_BACKTEST_METHOD_NAME_UPDATE_STORAGE = "StorageBacktestUtils._updateStorage";
-const STORAGE_BACKTEST_METHOD_NAME_HANDLE_OPENED = "StorageBacktestUtils.handleOpened";
-const STORAGE_BACKTEST_METHOD_NAME_HANDLE_CLOSED = "StorageBacktestUtils.handleClosed";
-const STORAGE_BACKTEST_METHOD_NAME_HANDLE_SCHEDULED = "StorageBacktestUtils.handleScheduled";
-const STORAGE_BACKTEST_METHOD_NAME_HANDLE_CANCELLED = "StorageBacktestUtils.handleCancelled";
-const STORAGE_BACKTEST_METHOD_NAME_FIND_BY_ID = "StorageBacktestUtils.findById";
-const STORAGE_BACKTEST_METHOD_NAME_LIST = "StorageBacktestUtils.list";
-const STORAGE_LIVE_METHOD_NAME_WAIT_FOR_INIT = "StorageLiveUtils.waitForInit";
-const STORAGE_LIVE_METHOD_NAME_UPDATE_STORAGE = "StorageLiveUtils._updateStorage";
-const STORAGE_LIVE_METHOD_NAME_HANDLE_OPENED = "StorageLiveUtils.handleOpened";
-const STORAGE_LIVE_METHOD_NAME_HANDLE_CLOSED = "StorageLiveUtils.handleClosed";
-const STORAGE_LIVE_METHOD_NAME_HANDLE_SCHEDULED = "StorageLiveUtils.handleScheduled";
-const STORAGE_LIVE_METHOD_NAME_HANDLE_CANCELLED = "StorageLiveUtils.handleCancelled";
-const STORAGE_LIVE_METHOD_NAME_FIND_BY_ID = "StorageLiveUtils.findById";
-const STORAGE_LIVE_METHOD_NAME_LIST = "StorageLiveUtils.list";
+const STORAGE_BACKTEST_METHOD_NAME_WAIT_FOR_INIT = "StoragePersistBacktestUtils.waitForInit";
+const STORAGE_BACKTEST_METHOD_NAME_UPDATE_STORAGE = "StoragePersistBacktestUtils._updateStorage";
+const STORAGE_BACKTEST_METHOD_NAME_HANDLE_OPENED = "StoragePersistBacktestUtils.handleOpened";
+const STORAGE_BACKTEST_METHOD_NAME_HANDLE_CLOSED = "StoragePersistBacktestUtils.handleClosed";
+const STORAGE_BACKTEST_METHOD_NAME_HANDLE_SCHEDULED = "StoragePersistBacktestUtils.handleScheduled";
+const STORAGE_BACKTEST_METHOD_NAME_HANDLE_CANCELLED = "StoragePersistBacktestUtils.handleCancelled";
+const STORAGE_BACKTEST_METHOD_NAME_FIND_BY_ID = "StoragePersistBacktestUtils.findById";
+const STORAGE_BACKTEST_METHOD_NAME_LIST = "StoragePersistBacktestUtils.list";
+const STORAGE_LIVE_METHOD_NAME_WAIT_FOR_INIT = "StoragePersistLiveUtils.waitForInit";
+const STORAGE_LIVE_METHOD_NAME_UPDATE_STORAGE = "StoragePersistLiveUtils._updateStorage";
+const STORAGE_LIVE_METHOD_NAME_HANDLE_OPENED = "StoragePersistLiveUtils.handleOpened";
+const STORAGE_LIVE_METHOD_NAME_HANDLE_CLOSED = "StoragePersistLiveUtils.handleClosed";
+const STORAGE_LIVE_METHOD_NAME_HANDLE_SCHEDULED = "StoragePersistLiveUtils.handleScheduled";
+const STORAGE_LIVE_METHOD_NAME_HANDLE_CANCELLED = "StoragePersistLiveUtils.handleCancelled";
+const STORAGE_LIVE_METHOD_NAME_FIND_BY_ID = "StoragePersistLiveUtils.findById";
+const STORAGE_LIVE_METHOD_NAME_LIST = "StoragePersistLiveUtils.list";
+const STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_OPENED = "StorageMemoryBacktestUtils.handleOpened";
+const STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_CLOSED = "StorageMemoryBacktestUtils.handleClosed";
+const STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_SCHEDULED = "StorageMemoryBacktestUtils.handleScheduled";
+const STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_CANCELLED = "StorageMemoryBacktestUtils.handleCancelled";
+const STORAGE_MEMORY_BACKTEST_METHOD_NAME_FIND_BY_ID = "StorageMemoryBacktestUtils.findById";
+const STORAGE_MEMORY_BACKTEST_METHOD_NAME_LIST = "StorageMemoryBacktestUtils.list";
+const STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_OPENED = "StorageMemoryLiveUtils.handleOpened";
+const STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_CLOSED = "StorageMemoryLiveUtils.handleClosed";
+const STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_SCHEDULED = "StorageMemoryLiveUtils.handleScheduled";
+const STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_CANCELLED = "StorageMemoryLiveUtils.handleCancelled";
+const STORAGE_MEMORY_LIVE_METHOD_NAME_FIND_BY_ID = "StorageMemoryLiveUtils.findById";
+const STORAGE_MEMORY_LIVE_METHOD_NAME_LIST = "StorageMemoryLiveUtils.list";
 const STORAGE_ADAPTER_METHOD_NAME_ENABLE = "StorageAdapter.enable";
 const STORAGE_ADAPTER_METHOD_NAME_DISABLE = "StorageAdapter.disable";
 const STORAGE_ADAPTER_METHOD_NAME_FIND_SIGNAL_BY_ID = "StorageAdapter.findSignalById";
 const STORAGE_ADAPTER_METHOD_NAME_LIST_SIGNAL_BACKTEST = "StorageAdapter.listSignalBacktest";
 const STORAGE_ADAPTER_METHOD_NAME_LIST_SIGNAL_LIVE = "StorageAdapter.listSignalLive";
+const STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_ADAPTER = "StorageBacktestAdapter.useStorageAdapter";
+const STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_DUMMY = "StorageBacktestAdapter.useDummy";
+const STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_PERSIST = "StorageBacktestAdapter.usePersist";
+const STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_MEMORY = "StorageBacktestAdapter.useMemory";
+const STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_ADAPTER = "StorageLiveAdapter.useStorageAdapter";
+const STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_DUMMY = "StorageLiveAdapter.useDummy";
+const STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_PERSIST = "StorageLiveAdapter.usePersist";
+const STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_MEMORY = "StorageLiveAdapter.useMemory";
 /**
- * Utility class for managing backtest signal history.
- *
- * Stores trading signal history for admin dashboard display during backtesting
- * with automatic initialization, deduplication, and storage limits.
- *
- * @example
- * ```typescript
- * import { StorageBacktestUtils } from "./classes/Storage";
+ * Persistent storage adapter for backtest signals.
  *
- * const storage = new StorageBacktestUtils();
- *
- * // Handle signal events
- * await storage.handleOpened(tickResult);
- * await storage.handleClosed(tickResult);
+ * Features:
+ * - Persists signals to disk using PersistStorageAdapter
+ * - Lazy initialization with singleshot pattern
+ * - Maintains up to MAX_SIGNALS (25) most recent signals
+ * - Handles signal lifecycle events (opened, closed, scheduled, cancelled)
+ * - Prevents duplicate updates based on timestamp comparison
  *
- * // Query signals
- * const signal = await storage.findById("signal-123");
- * const allSignals = await storage.list();
- * ```
+ * Use this adapter (default) for backtest signal persistence across sessions.
  */
-class StorageBacktestUtils {
+class StoragePersistBacktestUtils {
     constructor() {
         /**
-         * Initializes storage by loading existing signal history from persist layer.
-         * Uses singleshot to ensure initialization happens only once.
+         * Singleshot initialization function that loads signals from disk.
+         * Protected by singleshot to ensure one-time execution.
          */
         this.waitForInit = functoolsKit.singleshot(async () => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_WAIT_FOR_INIT);
@@ -31675,9 +31903,8 @@ class StorageBacktestUtils {
         });
         /**
          * Handles signal opened event.
-         *
-         * @param tick - Tick result containing opened signal data
-         * @returns Promise resolving when storage is updated
+         * Updates storage with opened status if not stale.
+         * @param tick - The opened signal tick data
          */
         this.handleOpened = async (tick) => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_HANDLE_OPENED, {
@@ -31699,9 +31926,8 @@ class StorageBacktestUtils {
         };
         /**
          * Handles signal closed event.
-         *
-         * @param tick - Tick result containing closed signal data
-         * @returns Promise resolving when storage is updated
+         * Updates storage with closed status and PnL if not stale.
+         * @param tick - The closed signal tick data
          */
         this.handleClosed = async (tick) => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_HANDLE_CLOSED, {
@@ -31724,9 +31950,8 @@ class StorageBacktestUtils {
         };
         /**
          * Handles signal scheduled event.
-         *
-         * @param tick - Tick result containing scheduled signal data
-         * @returns Promise resolving when storage is updated
+         * Updates storage with scheduled status if not stale.
+         * @param tick - The scheduled signal tick data
          */
         this.handleScheduled = async (tick) => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_HANDLE_SCHEDULED, {
@@ -31748,9 +31973,8 @@ class StorageBacktestUtils {
         };
         /**
          * Handles signal cancelled event.
-         *
-         * @param tick - Tick result containing cancelled signal data
-         * @returns Promise resolving when storage is updated
+         * Updates storage with cancelled status if not stale.
+         * @param tick - The cancelled signal tick data
          */
         this.handleCancelled = async (tick) => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_HANDLE_CANCELLED, {
@@ -31771,10 +31995,9 @@ class StorageBacktestUtils {
             await this._updateStorage();
         };
         /**
-         * Finds a signal by its unique identifier.
-         *
-         * @param id - Signal identifier
-         * @returns Promise resolving to signal row or null if not found
+         * Finds a signal by its ID.
+         * @param id - The signal ID to search for
+         * @returns The signal row or null if not found
          */
         this.findById = async (id) => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_FIND_BY_ID, { id });
@@ -31782,9 +32005,8 @@ class StorageBacktestUtils {
             return this._signals.get(id) ?? null;
         };
         /**
-         * Lists all stored backtest signals.
-         *
-         * @returns Promise resolving to array of signal rows
+         * Lists all stored signals.
+         * @returns Array of all signal rows
          */
         this.list = async () => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_LIST);
@@ -31793,15 +32015,14 @@ class StorageBacktestUtils {
         };
     }
     /**
-     * Persists current signal history to storage.
-     * Sorts by priority and limits to MAX_SIGNALS entries.
-     *
-     * @throws Error if storage not initialized
+     * Persists the current signal map to disk storage.
+     * Sorts signals by priority and keeps only the most recent MAX_SIGNALS.
+     * @throws Error if not initialized
      */
     async _updateStorage() {
         bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_UPDATE_STORAGE);
         if (!this._signals) {
-            throw new Error("StorageBacktestUtils not initialized. Call waitForInit first.");
+            throw new Error("StoragePersistBacktestUtils not initialized. Call waitForInit first.");
         }
         const signalList = Array.from(this._signals.values());
         signalList.sort((a, b) => a.priority - b.priority);
@@ -31809,31 +32030,190 @@ class StorageBacktestUtils {
     }
 }
 /**
- * Utility class for managing live trading signal history.
+ * In-memory storage adapter for backtest signals.
  *
- * Stores trading signal history for admin dashboard display during live trading
- * with automatic initialization, deduplication, and storage limits.
+ * Features:
+ * - Stores signals in memory only (no persistence)
+ * - Fast read/write operations
+ * - Data is lost when application restarts
+ * - Handles signal lifecycle events (opened, closed, scheduled, cancelled)
+ * - Prevents duplicate updates based on timestamp comparison
  *
- * @example
- * ```typescript
- * import { StorageLiveUtils } from "./classes/Storage";
+ * Use this adapter for testing or when persistence is not required.
+ */
+class StorageMemoryBacktestUtils {
+    constructor() {
+        /** Map of signal IDs to signal rows */
+        this._signals = new Map();
+        /**
+         * Handles signal opened event.
+         * Updates in-memory storage with opened status if not stale.
+         * @param tick - The opened signal tick data
+         */
+        this.handleOpened = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_OPENED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "opened",
+                priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Handles signal closed event.
+         * Updates in-memory storage with closed status and PnL if not stale.
+         * @param tick - The closed signal tick data
+         */
+        this.handleClosed = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_CLOSED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "closed",
+                priority: Date.now(),
+                pnl: tick.pnl,
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Handles signal scheduled event.
+         * Updates in-memory storage with scheduled status if not stale.
+         * @param tick - The scheduled signal tick data
+         */
+        this.handleScheduled = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_SCHEDULED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "scheduled",
+                priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Handles signal cancelled event.
+         * Updates in-memory storage with cancelled status if not stale.
+         * @param tick - The cancelled signal tick data
+         */
+        this.handleCancelled = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_BACKTEST_METHOD_NAME_HANDLE_CANCELLED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "cancelled",
+                priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Finds a signal by its ID.
+         * @param id - The signal ID to search for
+         * @returns The signal row or null if not found
+         */
+        this.findById = async (id) => {
+            bt.loggerService.info(STORAGE_MEMORY_BACKTEST_METHOD_NAME_FIND_BY_ID, { id });
+            return this._signals.get(id) ?? null;
+        };
+        /**
+         * Lists all stored signals.
+         * @returns Array of all signal rows
+         */
+        this.list = async () => {
+            bt.loggerService.info(STORAGE_MEMORY_BACKTEST_METHOD_NAME_LIST);
+            return Array.from(this._signals.values());
+        };
+    }
+}
+/**
+ * Dummy storage adapter for backtest signals that discards all writes.
+ *
+ * Features:
+ * - No-op implementation for all methods
+ * - findById always returns null
+ * - list always returns empty array
  *
- * const storage = new StorageLiveUtils();
+ * Use this adapter to disable backtest signal storage completely.
+ */
+class StorageDummyBacktestUtils {
+    constructor() {
+        /**
+         * No-op handler for signal opened event.
+         */
+        this.handleOpened = async () => {
+        };
+        /**
+         * No-op handler for signal closed event.
+         */
+        this.handleClosed = async () => {
+        };
+        /**
+         * No-op handler for signal scheduled event.
+         */
+        this.handleScheduled = async () => {
+        };
+        /**
+         * No-op handler for signal cancelled event.
+         */
+        this.handleCancelled = async () => {
+        };
+        /**
+         * Always returns null (no storage).
+         * @returns null
+         */
+        this.findById = async () => {
+            return null;
+        };
+        /**
+         * Always returns empty array (no storage).
+         * @returns Empty array
+         */
+        this.list = async () => {
+            return [];
+        };
+    }
+}
+/**
+ * Persistent storage adapter for live trading signals.
  *
- * // Handle signal events
- * await storage.handleOpened(tickResult);
- * await storage.handleClosed(tickResult);
+ * Features:
+ * - Persists signals to disk using PersistStorageAdapter
+ * - Lazy initialization with singleshot pattern
+ * - Maintains up to MAX_SIGNALS (25) most recent signals
+ * - Handles signal lifecycle events (opened, closed, scheduled, cancelled)
+ * - Prevents duplicate updates based on timestamp comparison
  *
- * // Query signals
- * const signal = await storage.findById("signal-123");
- * const allSignals = await storage.list();
- * ```
+ * Use this adapter (default) for live signal persistence across sessions.
  */
-class StorageLiveUtils {
+class StoragePersistLiveUtils {
     constructor() {
         /**
-         * Initializes storage by loading existing signal history from persist layer.
-         * Uses singleshot to ensure initialization happens only once.
+         * Singleshot initialization function that loads signals from disk.
+         * Protected by singleshot to ensure one-time execution.
          */
         this.waitForInit = functoolsKit.singleshot(async () => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_WAIT_FOR_INIT);
@@ -31845,9 +32225,8 @@ class StorageLiveUtils {
         });
         /**
          * Handles signal opened event.
-         *
-         * @param tick - Tick result containing opened signal data
-         * @returns Promise resolving when history is updated
+         * Updates storage with opened status if not stale.
+         * @param tick - The opened signal tick data
          */
         this.handleOpened = async (tick) => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_HANDLE_OPENED, {
@@ -31869,9 +32248,8 @@ class StorageLiveUtils {
         };
         /**
          * Handles signal closed event.
-         *
-         * @param tick - Tick result containing closed signal data
-         * @returns Promise resolving when history is updated
+         * Updates storage with closed status and PnL if not stale.
+         * @param tick - The closed signal tick data
          */
         this.handleClosed = async (tick) => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_HANDLE_CLOSED, {
@@ -31894,9 +32272,8 @@ class StorageLiveUtils {
         };
         /**
          * Handles signal scheduled event.
-         *
-         * @param tick - Tick result containing scheduled signal data
-         * @returns Promise resolving when history is updated
+         * Updates storage with scheduled status if not stale.
+         * @param tick - The scheduled signal tick data
          */
         this.handleScheduled = async (tick) => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_HANDLE_SCHEDULED, {
@@ -31918,9 +32295,8 @@ class StorageLiveUtils {
         };
         /**
          * Handles signal cancelled event.
-         *
-         * @param tick - Tick result containing cancelled signal data
-         * @returns Promise resolving when history is updated
+         * Updates storage with cancelled status if not stale.
+         * @param tick - The cancelled signal tick data
          */
         this.handleCancelled = async (tick) => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_HANDLE_CANCELLED, {
@@ -31941,10 +32317,9 @@ class StorageLiveUtils {
             await this._updateStorage();
         };
         /**
-         * Finds a signal by its unique identifier.
-         *
-         * @param id - Signal identifier
-         * @returns Promise resolving to signal row or null if not found
+         * Finds a signal by its ID.
+         * @param id - The signal ID to search for
+         * @returns The signal row or null if not found
          */
         this.findById = async (id) => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_FIND_BY_ID, { id });
@@ -31952,9 +32327,8 @@ class StorageLiveUtils {
             return this._signals.get(id) ?? null;
         };
         /**
-         * Lists all stored live signals.
-         *
-         * @returns Promise resolving to array of signal rows
+         * Lists all stored signals.
+         * @returns Array of all signal rows
          */
         this.list = async () => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_LIST);
@@ -31963,15 +32337,14 @@ class StorageLiveUtils {
         };
     }
     /**
-     * Persists current signal history to storage.
-     * Sorts by priority and limits to MAX_SIGNALS entries.
-     *
-     * @throws Error if storage not initialized
+     * Persists the current signal map to disk storage.
+     * Sorts signals by priority and keeps only the most recent MAX_SIGNALS.
+     * @throws Error if not initialized
      */
     async _updateStorage() {
         bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_UPDATE_STORAGE);
         if (!this._signals) {
-            throw new Error("StorageLiveUtils not initialized. Call waitForInit first.");
+            throw new Error("StoragePersistLiveUtils not initialized. Call waitForInit first.");
         }
         const signalList = Array.from(this._signals.values());
         signalList.sort((a, b) => a.priority - b.priority);
@@ -31979,36 +32352,385 @@ class StorageLiveUtils {
     }
 }
 /**
- * Main storage adapter for signal history management.
+ * In-memory storage adapter for live trading signals.
  *
- * Provides unified interface for accessing backtest and live signal history
- * for admin dashboard. Subscribes to signal emitters and automatically
- * updates history on signal events.
+ * Features:
+ * - Stores signals in memory only (no persistence)
+ * - Fast read/write operations
+ * - Data is lost when application restarts
+ * - Handles signal lifecycle events (opened, closed, scheduled, cancelled)
+ * - Prevents duplicate updates based on timestamp comparison
  *
- * @example
- * ```typescript
- * import { Storage } from "./classes/Storage";
+ * Use this adapter for testing or when persistence is not required.
+ */
+class StorageMemoryLiveUtils {
+    constructor() {
+        /** Map of signal IDs to signal rows */
+        this._signals = new Map();
+        /**
+         * Handles signal opened event.
+         * Updates in-memory storage with opened status if not stale.
+         * @param tick - The opened signal tick data
+         */
+        this.handleOpened = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_OPENED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "opened",
+                priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Handles signal closed event.
+         * Updates in-memory storage with closed status and PnL if not stale.
+         * @param tick - The closed signal tick data
+         */
+        this.handleClosed = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_CLOSED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "closed",
+                priority: Date.now(),
+                pnl: tick.pnl,
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Handles signal scheduled event.
+         * Updates in-memory storage with scheduled status if not stale.
+         * @param tick - The scheduled signal tick data
+         */
+        this.handleScheduled = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_SCHEDULED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "scheduled",
+                priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Handles signal cancelled event.
+         * Updates in-memory storage with cancelled status if not stale.
+         * @param tick - The cancelled signal tick data
+         */
+        this.handleCancelled = async (tick) => {
+            bt.loggerService.info(STORAGE_MEMORY_LIVE_METHOD_NAME_HANDLE_CANCELLED, {
+                signalId: tick.signal.id,
+            });
+            const lastStorage = this._signals.get(tick.signal.id);
+            if (lastStorage && lastStorage.updatedAt > tick.createdAt) {
+                return;
+            }
+            this._signals.set(tick.signal.id, {
+                ...tick.signal,
+                status: "cancelled",
+                priority: Date.now(),
+                createdAt: lastStorage ? lastStorage.createdAt : tick.createdAt,
+                updatedAt: tick.createdAt,
+            });
+        };
+        /**
+         * Finds a signal by its ID.
+         * @param id - The signal ID to search for
+         * @returns The signal row or null if not found
+         */
+        this.findById = async (id) => {
+            bt.loggerService.info(STORAGE_MEMORY_LIVE_METHOD_NAME_FIND_BY_ID, { id });
+            return this._signals.get(id) ?? null;
+        };
+        /**
+         * Lists all stored signals.
+         * @returns Array of all signal rows
+         */
+        this.list = async () => {
+            bt.loggerService.info(STORAGE_MEMORY_LIVE_METHOD_NAME_LIST);
+            return Array.from(this._signals.values());
+        };
+    }
+}
+/**
+ * Dummy storage adapter for live trading signals that discards all writes.
  *
- * // Enable signal history tracking
- * const unsubscribe = Storage.enable();
+ * Features:
+ * - No-op implementation for all methods
+ * - findById always returns null
+ * - list always returns empty array
  *
- * // Query signals
- * const backtestSignals = await Storage.listSignalBacktest();
- * const liveSignals = await Storage.listSignalLive();
- * const signal = await Storage.findSignalById("signal-123");
+ * Use this adapter to disable live signal storage completely.
+ */
+class StorageDummyLiveUtils {
+    constructor() {
+        /**
+         * No-op handler for signal opened event.
+         */
+        this.handleOpened = async () => {
+        };
+        /**
+         * No-op handler for signal closed event.
+         */
+        this.handleClosed = async () => {
+        };
+        /**
+         * No-op handler for signal scheduled event.
+         */
+        this.handleScheduled = async () => {
+        };
+        /**
+         * No-op handler for signal cancelled event.
+         */
+        this.handleCancelled = async () => {
+        };
+        /**
+         * Always returns null (no storage).
+         * @returns null
+         */
+        this.findById = async () => {
+            return null;
+        };
+        /**
+         * Always returns empty array (no storage).
+         * @returns Empty array
+         */
+        this.list = async () => {
+            return [];
+        };
+    }
+}
+/**
+ * Backtest storage adapter with pluggable storage backend.
  *
- * // Disable tracking
- * Storage.disable();
- * ```
+ * Features:
+ * - Adapter pattern for swappable storage implementations
+ * - Default adapter: StoragePersistBacktestUtils (persistent storage)
+ * - Alternative adapters: StorageMemoryBacktestUtils, StorageDummyBacktestUtils
+ * - Convenience methods: usePersist(), useMemory(), useDummy()
+ */
+class StorageBacktestAdapter {
+    constructor() {
+        /** Internal storage utils instance */
+        this._signalBacktestUtils = new StorageMemoryBacktestUtils();
+        /**
+         * Handles signal opened event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The opened signal tick data
+         */
+        this.handleOpened = async (tick) => {
+            return await this._signalBacktestUtils.handleOpened(tick);
+        };
+        /**
+         * Handles signal closed event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The closed signal tick data
+         */
+        this.handleClosed = async (tick) => {
+            return await this._signalBacktestUtils.handleClosed(tick);
+        };
+        /**
+         * Handles signal scheduled event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The scheduled signal tick data
+         */
+        this.handleScheduled = async (tick) => {
+            return await this._signalBacktestUtils.handleScheduled(tick);
+        };
+        /**
+         * Handles signal cancelled event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The cancelled signal tick data
+         */
+        this.handleCancelled = async (tick) => {
+            return await this._signalBacktestUtils.handleCancelled(tick);
+        };
+        /**
+         * Finds a signal by its ID.
+         * Proxies call to the underlying storage adapter.
+         * @param id - The signal ID to search for
+         * @returns The signal row or null if not found
+         */
+        this.findById = async (id) => {
+            return await this._signalBacktestUtils.findById(id);
+        };
+        /**
+         * Lists all stored signals.
+         * Proxies call to the underlying storage adapter.
+         * @returns Array of all signal rows
+         */
+        this.list = async () => {
+            return await this._signalBacktestUtils.list();
+        };
+        /**
+         * Sets the storage adapter constructor.
+         * All future storage operations will use this adapter.
+         *
+         * @param Ctor - Constructor for storage adapter
+         */
+        this.useStorageAdapter = (Ctor) => {
+            bt.loggerService.info(STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_ADAPTER);
+            this._signalBacktestUtils = Reflect.construct(Ctor, []);
+        };
+        /**
+         * Switches to dummy storage adapter.
+         * All future storage writes will be no-ops.
+         */
+        this.useDummy = () => {
+            bt.loggerService.info(STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_DUMMY);
+            this._signalBacktestUtils = new StorageDummyBacktestUtils();
+        };
+        /**
+         * Switches to persistent storage adapter (default).
+         * Signals will be persisted to disk.
+         */
+        this.usePersist = () => {
+            bt.loggerService.info(STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_PERSIST);
+            this._signalBacktestUtils = new StoragePersistBacktestUtils();
+        };
+        /**
+         * Switches to in-memory storage adapter.
+         * Signals will be stored in memory only.
+         */
+        this.useMemory = () => {
+            bt.loggerService.info(STORAGE_BACKTEST_ADAPTER_METHOD_NAME_USE_MEMORY);
+            this._signalBacktestUtils = new StorageMemoryBacktestUtils();
+        };
+    }
+}
+/**
+ * Live trading storage adapter with pluggable storage backend.
+ *
+ * Features:
+ * - Adapter pattern for swappable storage implementations
+ * - Default adapter: StoragePersistLiveUtils (persistent storage)
+ * - Alternative adapters: StorageMemoryLiveUtils, StorageDummyLiveUtils
+ * - Convenience methods: usePersist(), useMemory(), useDummy()
+ */
+class StorageLiveAdapter {
+    constructor() {
+        /** Internal storage utils instance */
+        this._signalLiveUtils = new StoragePersistLiveUtils();
+        /**
+         * Handles signal opened event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The opened signal tick data
+         */
+        this.handleOpened = async (tick) => {
+            return await this._signalLiveUtils.handleOpened(tick);
+        };
+        /**
+         * Handles signal closed event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The closed signal tick data
+         */
+        this.handleClosed = async (tick) => {
+            return await this._signalLiveUtils.handleClosed(tick);
+        };
+        /**
+         * Handles signal scheduled event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The scheduled signal tick data
+         */
+        this.handleScheduled = async (tick) => {
+            return await this._signalLiveUtils.handleScheduled(tick);
+        };
+        /**
+         * Handles signal cancelled event.
+         * Proxies call to the underlying storage adapter.
+         * @param tick - The cancelled signal tick data
+         */
+        this.handleCancelled = async (tick) => {
+            return await this._signalLiveUtils.handleCancelled(tick);
+        };
+        /**
+         * Finds a signal by its ID.
+         * Proxies call to the underlying storage adapter.
+         * @param id - The signal ID to search for
+         * @returns The signal row or null if not found
+         */
+        this.findById = async (id) => {
+            return await this._signalLiveUtils.findById(id);
+        };
+        /**
+         * Lists all stored signals.
+         * Proxies call to the underlying storage adapter.
+         * @returns Array of all signal rows
+         */
+        this.list = async () => {
+            return await this._signalLiveUtils.list();
+        };
+        /**
+         * Sets the storage adapter constructor.
+         * All future storage operations will use this adapter.
+         *
+         * @param Ctor - Constructor for storage adapter
+         */
+        this.useStorageAdapter = (Ctor) => {
+            bt.loggerService.info(STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_ADAPTER);
+            this._signalLiveUtils = Reflect.construct(Ctor, []);
+        };
+        /**
+         * Switches to dummy storage adapter.
+         * All future storage writes will be no-ops.
+         */
+        this.useDummy = () => {
+            bt.loggerService.info(STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_DUMMY);
+            this._signalLiveUtils = new StorageDummyLiveUtils();
+        };
+        /**
+         * Switches to persistent storage adapter (default).
+         * Signals will be persisted to disk.
+         */
+        this.usePersist = () => {
+            bt.loggerService.info(STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_PERSIST);
+            this._signalLiveUtils = new StoragePersistLiveUtils();
+        };
+        /**
+         * Switches to in-memory storage adapter.
+         * Signals will be stored in memory only.
+         */
+        this.useMemory = () => {
+            bt.loggerService.info(STORAGE_LIVE_ADAPTER_METHOD_NAME_USE_MEMORY);
+            this._signalLiveUtils = new StorageMemoryLiveUtils();
+        };
+    }
+}
+/**
+ * Main storage adapter that manages both backtest and live signal storage.
+ *
+ * Features:
+ * - Subscribes to signal emitters for automatic storage updates
+ * - Provides unified access to both backtest and live signals
+ * - Singleshot enable pattern prevents duplicate subscriptions
+ * - Cleanup function for proper unsubscription
  */
 class StorageAdapter {
     constructor() {
-        this._signalLiveUtils = new StorageLiveUtils();
-        this._signalBacktestUtils = new StorageBacktestUtils();
         /**
-         * Enables signal history tracking by subscribing to emitters.
+         * Enables signal storage by subscribing to signal emitters.
+         * Uses singleshot to ensure one-time subscription.
          *
-         * @returns Cleanup function to unsubscribe from all emitters
+         * @returns Cleanup function that unsubscribes from all emitters
          */
         this.enable = functoolsKit.singleshot(() => {
             bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_ENABLE);
@@ -32017,31 +32739,31 @@ class StorageAdapter {
             {
                 const unBacktestOpen = signalBacktestEmitter
                     .filter(({ action }) => action === "opened")
-                    .connect((tick) => this._signalBacktestUtils.handleOpened(tick));
+                    .connect((tick) => StorageBacktest.handleOpened(tick));
                 const unBacktestClose = signalBacktestEmitter
                     .filter(({ action }) => action === "closed")
-                    .connect((tick) => this._signalBacktestUtils.handleClosed(tick));
+                    .connect((tick) => StorageBacktest.handleClosed(tick));
                 const unBacktestScheduled = signalBacktestEmitter
                     .filter(({ action }) => action === "scheduled")
-                    .connect((tick) => this._signalBacktestUtils.handleScheduled(tick));
+                    .connect((tick) => StorageBacktest.handleScheduled(tick));
                 const unBacktestCancelled = signalBacktestEmitter
                     .filter(({ action }) => action === "cancelled")
-                    .connect((tick) => this._signalBacktestUtils.handleCancelled(tick));
+                    .connect((tick) => StorageBacktest.handleCancelled(tick));
                 unBacktest = functoolsKit.compose(() => unBacktestOpen(), () => unBacktestClose(), () => unBacktestScheduled(), () => unBacktestCancelled());
             }
             {
                 const unLiveOpen = signalLiveEmitter
                     .filter(({ action }) => action === "opened")
-                    .connect((tick) => this._signalLiveUtils.handleOpened(tick));
+                    .connect((tick) => StorageLive.handleOpened(tick));
                 const unLiveClose = signalLiveEmitter
                     .filter(({ action }) => action === "closed")
-                    .connect((tick) => this._signalLiveUtils.handleClosed(tick));
+                    .connect((tick) => StorageLive.handleClosed(tick));
                 const unLiveScheduled = signalLiveEmitter
                     .filter(({ action }) => action === "scheduled")
-                    .connect((tick) => this._signalLiveUtils.handleScheduled(tick));
+                    .connect((tick) => StorageLive.handleScheduled(tick));
                 const unLiveCancelled = signalLiveEmitter
                     .filter(({ action }) => action === "cancelled")
-                    .connect((tick) => this._signalLiveUtils.handleCancelled(tick));
+                    .connect((tick) => StorageLive.handleCancelled(tick));
                 unLive = functoolsKit.compose(() => unLiveOpen(), () => unLiveClose(), () => unLiveScheduled(), () => unLiveCancelled());
             }
             return () => {
@@ -32051,7 +32773,8 @@ class StorageAdapter {
             };
         });
         /**
-         * Disables signal history tracking by unsubscribing from emitters.
+         * Disables signal storage by unsubscribing from all emitters.
+         * Safe to call multiple times.
          */
         this.disable = () => {
             bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_DISABLE);
@@ -32061,11 +32784,12 @@ class StorageAdapter {
             }
         };
         /**
-         * Finds a signal by ID across both backtest and live history.
+         * Finds a signal by ID across both backtest and live storage.
          *
-         * @param id - Signal identifier
-         * @returns Promise resolving to signal row
-         * @throws Error if signal not found in either storage
+         * @param id - The signal ID to search for
+         * @returns The signal row or throws if not found
+         * @throws Error if StorageAdapter is not enabled
+         * @throws Error if signal is not found in either storage
          */
         this.findSignalById = async (id) => {
             bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_FIND_SIGNAL_BY_ID, { id });
@@ -32073,41 +32797,57 @@ class StorageAdapter {
                 throw new Error("StorageAdapter is not enabled. Call enable() first.");
             }
             let result = null;
-            if ((result = await this._signalBacktestUtils.findById(id))) {
+            if ((result = await StorageBacktest.findById(id))) {
                 return result;
             }
-            if ((result = await this._signalLiveUtils.findById(id))) {
+            if ((result = await StorageLive.findById(id))) {
                 return result;
             }
             throw new Error(`Storage signal with id ${id} not found`);
         };
         /**
-         * Lists all backtest signal history.
+         * Lists all backtest signals from storage.
          *
-         * @returns Promise resolving to array of backtest signal rows
+         * @returns Array of all backtest signal rows
+         * @throws Error if StorageAdapter is not enabled
          */
         this.listSignalBacktest = async () => {
             bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_LIST_SIGNAL_BACKTEST);
             if (!this.enable.hasValue()) {
                 throw new Error("StorageAdapter is not enabled. Call enable() first.");
             }
-            return await this._signalBacktestUtils.list();
+            return await StorageBacktest.list();
         };
         /**
-         * Lists all live signal history.
+         * Lists all live signals from storage.
          *
-         * @returns Promise resolving to array of live signal rows
+         * @returns Array of all live signal rows
+         * @throws Error if StorageAdapter is not enabled
          */
         this.listSignalLive = async () => {
             bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_LIST_SIGNAL_LIVE);
             if (!this.enable.hasValue()) {
                 throw new Error("StorageAdapter is not enabled. Call enable() first.");
             }
-            return await this._signalLiveUtils.list();
+            return await StorageLive.list();
         };
     }
 }
+/**
+ * Global singleton instance of StorageAdapter.
+ * Provides unified signal storage management for backtest and live trading.
+ */
 const Storage = new StorageAdapter();
+/**
+ * Global singleton instance of StorageLiveAdapter.
+ * Provides live trading signal storage with pluggable backends.
+ */
+const StorageLive = new StorageLiveAdapter();
+/**
+ * Global singleton instance of StorageBacktestAdapter.
+ * Provides backtest signal storage with pluggable backends.
+ */
+const StorageBacktest = new StorageBacktestAdapter();
 
 const EXCHANGE_METHOD_NAME_GET_CANDLES = "ExchangeUtils.getCandles";
 const EXCHANGE_METHOD_NAME_GET_AVERAGE_PRICE = "ExchangeUtils.getAveragePrice";
@@ -33201,6 +33941,12 @@ class NotificationInstance {
                 currentPrice: data.currentPrice,
                 priceOpen: data.data.priceOpen,
                 position: data.data.position,
+                priceTakeProfit: data.data.priceTakeProfit,
+                priceStopLoss: data.data.priceStopLoss,
+                originalPriceTakeProfit: data.data.originalPriceTakeProfit,
+                originalPriceStopLoss: data.data.originalPriceStopLoss,
+                scheduledAt: data.data.scheduledAt,
+                pendingAt: data.data.pendingAt,
                 createdAt: data.timestamp,
             });
         };
@@ -33221,6 +33967,12 @@ class NotificationInstance {
                 currentPrice: data.currentPrice,
                 priceOpen: data.data.priceOpen,
                 position: data.data.position,
+                priceTakeProfit: data.data.priceTakeProfit,
+                priceStopLoss: data.data.priceStopLoss,
+                originalPriceTakeProfit: data.data.originalPriceTakeProfit,
+                originalPriceStopLoss: data.data.originalPriceStopLoss,
+                scheduledAt: data.data.scheduledAt,
+                pendingAt: data.data.pendingAt,
                 createdAt: data.timestamp,
             });
         };
@@ -33240,6 +33992,12 @@ class NotificationInstance {
                 currentPrice: data.currentPrice,
                 priceOpen: data.data.priceOpen,
                 position: data.data.position,
+                priceTakeProfit: data.data.priceTakeProfit,
+                priceStopLoss: data.data.priceStopLoss,
+                originalPriceTakeProfit: data.data.originalPriceTakeProfit,
+                originalPriceStopLoss: data.data.originalPriceStopLoss,
+                scheduledAt: data.data.scheduledAt,
+                pendingAt: data.data.pendingAt,
                 createdAt: data.timestamp,
             });
         };
@@ -33258,6 +34016,14 @@ class NotificationInstance {
                     exchangeName: data.exchangeName,
                     percentToClose: data.percentToClose,
                     currentPrice: data.currentPrice,
+                    position: data.position,
+                    priceOpen: data.priceOpen,
+                    priceTakeProfit: data.priceTakeProfit,
+                    priceStopLoss: data.priceStopLoss,
+                    originalPriceTakeProfit: data.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.originalPriceStopLoss,
+                    scheduledAt: data.scheduledAt,
+                    pendingAt: data.pendingAt,
                     createdAt: data.timestamp,
                 });
             }
@@ -33272,6 +34038,14 @@ class NotificationInstance {
                     exchangeName: data.exchangeName,
                     percentToClose: data.percentToClose,
                     currentPrice: data.currentPrice,
+                    position: data.position,
+                    priceOpen: data.priceOpen,
+                    priceTakeProfit: data.priceTakeProfit,
+                    priceStopLoss: data.priceStopLoss,
+                    originalPriceTakeProfit: data.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.originalPriceStopLoss,
+                    scheduledAt: data.scheduledAt,
+                    pendingAt: data.pendingAt,
                     createdAt: data.timestamp,
                 });
             }
@@ -33285,6 +34059,14 @@ class NotificationInstance {
                     strategyName: data.strategyName,
                     exchangeName: data.exchangeName,
                     currentPrice: data.currentPrice,
+                    position: data.position,
+                    priceOpen: data.priceOpen,
+                    priceTakeProfit: data.priceTakeProfit,
+                    priceStopLoss: data.priceStopLoss,
+                    originalPriceTakeProfit: data.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.originalPriceStopLoss,
+                    scheduledAt: data.scheduledAt,
+                    pendingAt: data.pendingAt,
                     createdAt: data.timestamp,
                 });
             }
@@ -33299,6 +34081,14 @@ class NotificationInstance {
                     exchangeName: data.exchangeName,
                     percentShift: data.percentShift,
                     currentPrice: data.currentPrice,
+                    position: data.position,
+                    priceOpen: data.priceOpen,
+                    priceTakeProfit: data.priceTakeProfit,
+                    priceStopLoss: data.priceStopLoss,
+                    originalPriceTakeProfit: data.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.originalPriceStopLoss,
+                    scheduledAt: data.scheduledAt,
+                    pendingAt: data.pendingAt,
                     createdAt: data.timestamp,
                 });
             }
@@ -33313,6 +34103,14 @@ class NotificationInstance {
                     exchangeName: data.exchangeName,
                     percentShift: data.percentShift,
                     currentPrice: data.currentPrice,
+                    position: data.position,
+                    priceOpen: data.priceOpen,
+                    priceTakeProfit: data.priceTakeProfit,
+                    priceStopLoss: data.priceStopLoss,
+                    originalPriceTakeProfit: data.originalPriceTakeProfit,
+                    originalPriceStopLoss: data.originalPriceStopLoss,
+                    scheduledAt: data.scheduledAt,
+                    pendingAt: data.pendingAt,
                     createdAt: data.timestamp,
                 });
             }
@@ -34144,6 +34942,8 @@ exports.ReportBase = ReportBase;
 exports.Risk = Risk;
 exports.Schedule = Schedule;
 exports.Storage = Storage;
+exports.StorageBacktest = StorageBacktest;
+exports.StorageLive = StorageLive;
 exports.Strategy = Strategy;
 exports.Walker = Walker;
 exports.addActionSchema = addActionSchema;