backtest-kit 2.2.17 → 2.2.19

package/build/index.mjs

@@ -2808,6 +2808,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.
@@ -2847,73 +2852,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;
         }
     }
 };
@@ -3238,7 +3293,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}`);
         }
     }
@@ -3324,7 +3379,7 @@ const GET_SIGNAL_FN = 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,
         };
         // Валидируем сигнал перед возвратом
@@ -13468,6 +13523,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}`;
@@ -13477,7 +13534,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,
     },
     {
@@ -23606,7 +23663,7 @@ class RiskReportService {
                 strategyName: data.strategyName,
                 exchangeName: data.exchangeName,
                 frameName: data.frameName,
-                signalId: "",
+                signalId: data.pendingSignal?.id || "",
                 walkerName: "",
             });
         };
@@ -23771,8 +23828,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,
@@ -23798,6 +23863,14 @@ class StrategyReportService {
                 symbol,
                 timestamp,
                 createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             }, {
                 signalId: pendingRow.id,
                 exchangeName: context.exchangeName,
@@ -23816,8 +23889,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,
@@ -23843,6 +23924,14 @@ class StrategyReportService {
                 symbol,
                 timestamp,
                 createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             }, {
                 signalId: pendingRow.id,
                 exchangeName: context.exchangeName,
@@ -23861,8 +23950,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,
@@ -23888,6 +23985,14 @@ class StrategyReportService {
                 symbol,
                 timestamp,
                 createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             }, {
                 signalId: pendingRow.id,
                 exchangeName: context.exchangeName,
@@ -23906,8 +24011,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,
@@ -23933,6 +24046,14 @@ class StrategyReportService {
                 symbol,
                 timestamp,
                 createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             }, {
                 signalId: pendingRow.id,
                 exchangeName: context.exchangeName,
@@ -23950,8 +24071,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,
@@ -23975,6 +24104,14 @@ class StrategyReportService {
                 symbol,
                 timestamp,
                 createdAt,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             }, {
                 signalId: pendingRow.id,
                 exchangeName: context.exchangeName,
@@ -24014,35 +24151,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 = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven());
             return () => {
                 disposeFn();
@@ -24412,8 +24549,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,
@@ -24445,6 +24590,14 @@ class StrategyMarkdownService {
                 currentPrice,
                 createdAt,
                 backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             });
         };
         /**
@@ -24456,8 +24609,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,
@@ -24489,6 +24650,14 @@ class StrategyMarkdownService {
                 currentPrice,
                 createdAt,
                 backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             });
         };
         /**
@@ -24500,8 +24669,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,
@@ -24533,6 +24710,14 @@ class StrategyMarkdownService {
                 currentPrice,
                 createdAt,
                 backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             });
         };
         /**
@@ -24544,8 +24729,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,
@@ -24577,6 +24770,14 @@ class StrategyMarkdownService {
                 currentPrice,
                 createdAt,
                 backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             });
         };
         /**
@@ -24587,8 +24788,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,
@@ -24618,6 +24827,14 @@ class StrategyMarkdownService {
                 currentPrice,
                 createdAt,
                 backtest: isBacktest,
+                position,
+                priceOpen,
+                priceTakeProfit,
+                priceStopLoss,
+                originalPriceTakeProfit,
+                originalPriceStopLoss,
+                scheduledAt,
+                pendingAt,
             });
         };
         /**
@@ -24764,35 +24981,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 = compose(() => unCancelSchedule(), () => unClosePending(), () => unPartialProfit(), () => unPartialLoss(), () => unTrailingStop(), () => unTrailingTake(), () => unBreakeven());
             return () => {
                 disposeFn();
@@ -31597,53 +31814,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 = singleshot(async () => {
             bt.loggerService.info(STORAGE_BACKTEST_METHOD_NAME_WAIT_FOR_INIT);
@@ -31655,9 +31883,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, {
@@ -31679,9 +31906,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, {
@@ -31704,9 +31930,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, {
@@ -31728,9 +31953,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, {
@@ -31751,10 +31975,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 });
@@ -31762,9 +31985,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);
@@ -31773,15 +31995,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);
@@ -31789,31 +32010,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 = singleshot(async () => {
             bt.loggerService.info(STORAGE_LIVE_METHOD_NAME_WAIT_FOR_INIT);
@@ -31825,9 +32205,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, {
@@ -31849,9 +32228,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, {
@@ -31874,9 +32252,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, {
@@ -31898,9 +32275,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, {
@@ -31921,10 +32297,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 });
@@ -31932,9 +32307,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);
@@ -31943,15 +32317,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);
@@ -31959,36 +32332,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 = singleshot(() => {
             bt.loggerService.info(STORAGE_ADAPTER_METHOD_NAME_ENABLE);
@@ -31997,31 +32719,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 = 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 = compose(() => unLiveOpen(), () => unLiveClose(), () => unLiveScheduled(), () => unLiveCancelled());
             }
             return () => {
@@ -32031,7 +32753,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);
@@ -32041,11 +32764,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 });
@@ -32053,41 +32777,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";
@@ -33181,6 +33921,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,
             });
         };
@@ -33201,6 +33947,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,
             });
         };
@@ -33220,6 +33972,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,
             });
         };
@@ -33238,6 +33996,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,
                 });
             }
@@ -33252,6 +34018,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,
                 });
             }
@@ -33265,6 +34039,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,
                 });
             }
@@ -33279,6 +34061,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,
                 });
             }
@@ -33293,6 +34083,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,
                 });
             }
@@ -34094,4 +34892,4 @@ const set = (object, path, value) => {
     }
 };
 
-export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };
+export { ActionBase, Backtest, Breakeven, Cache, Constant, Exchange, ExecutionContextService, Heat, Live, Markdown, MarkdownFileBase, MarkdownFolderBase, MethodContextService, Notification, Partial, Performance, PersistBase, PersistBreakevenAdapter, PersistCandleAdapter, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PersistStorageAdapter, PositionSize, Report, ReportBase, Risk, Schedule, Storage, StorageBacktest, StorageLive, Strategy, Walker, addActionSchema, addExchangeSchema, addFrameSchema, addRiskSchema, addSizingSchema, addStrategySchema, addWalkerSchema, commitBreakeven, commitCancelScheduled, commitClosePending, commitPartialLoss, commitPartialProfit, commitTrailingStop, commitTrailingTake, emitters, formatPrice, formatQuantity, get, getActionSchema, getAveragePrice, getBacktestTimeframe, getCandles, getColumns, getConfig, getContext, getDate, getDefaultColumns, getDefaultConfig, getExchangeSchema, getFrameSchema, getMode, getOrderBook, getRawCandles, getRiskSchema, getSizingSchema, getStrategySchema, getSymbol, getWalkerSchema, hasTradeContext, backtest as lib, listExchangeSchema, listFrameSchema, listRiskSchema, listSizingSchema, listStrategySchema, listWalkerSchema, listenActivePing, listenActivePingOnce, listenBacktestProgress, listenBreakevenAvailable, listenBreakevenAvailableOnce, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenPartialLossAvailable, listenPartialLossAvailableOnce, listenPartialProfitAvailable, listenPartialProfitAvailableOnce, listenPerformance, listenRisk, listenRiskOnce, listenSchedulePing, listenSchedulePingOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenStrategyCommit, listenStrategyCommitOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, overrideActionSchema, overrideExchangeSchema, overrideFrameSchema, overrideRiskSchema, overrideSizingSchema, overrideStrategySchema, overrideWalkerSchema, parseArgs, roundTicks, set, setColumns, setConfig, setLogger, stopStrategy, validate };