backtest-kit 1.5.15 → 1.5.17

package/build/index.cjs

@@ -202,6 +202,7 @@ const markdownServices$1 = {
     heatMarkdownService: Symbol('heatMarkdownService'),
     partialMarkdownService: Symbol('partialMarkdownService'),
     outlineMarkdownService: Symbol('outlineMarkdownService'),
+    riskMarkdownService: Symbol('riskMarkdownService'),
 };
 const validationServices$1 = {
     exchangeValidationService: Symbol('exchangeValidationService'),
@@ -442,11 +443,12 @@ const GET_CANDLES_FN = async (dto, since, self) => {
         }
         catch (err) {
             const message = `ClientExchange GET_CANDLES_FN: attempt ${i + 1} failed for symbol=${dto.symbol}, interval=${dto.interval}, since=${since.toISOString()}, limit=${dto.limit}}`;
-            self.params.logger.warn(message, {
+            const payload = {
                 error: functoolsKit.errorData(err),
                 message: functoolsKit.getErrorMessage(err),
-            });
-            console.warn(message);
+            };
+            self.params.logger.warn(message, payload);
+            console.warn(message, payload);
             lastError = err;
             await functoolsKit.sleep(GLOBAL_CONFIG.CC_GET_CANDLES_RETRY_DELAY_MS);
         }
@@ -1725,6 +1727,12 @@ const partialProfitSubject = new functoolsKit.Subject();
  * Emits when a signal reaches a loss level (10%, 20%, 30%, etc).
  */
 const partialLossSubject = new functoolsKit.Subject();
+/**
+ * Risk rejection emitter for risk management violations.
+ * Emits ONLY when a signal is rejected due to risk validation failure.
+ * Does not emit for allowed signals (prevents spam).
+ */
+const riskSubject = new functoolsKit.Subject();
 
 var emitters = /*#__PURE__*/Object.freeze({
     __proto__: null,
@@ -1739,6 +1747,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     progressBacktestEmitter: progressBacktestEmitter,
     progressOptimizerEmitter: progressOptimizerEmitter,
     progressWalkerEmitter: progressWalkerEmitter,
+    riskSubject: riskSubject,
     signalBacktestEmitter: signalBacktestEmitter,
     signalEmitter: signalEmitter,
     signalLiveEmitter: signalLiveEmitter,
@@ -1825,6 +1834,9 @@ const VALIDATE_SIGNAL_FN = (signal, currentPrice, isScheduled) => {
     if (signal.position === undefined || signal.position === null) {
         errors.push('position is required and must be "long" or "short"');
     }
+    if (signal.position !== "long" && signal.position !== "short") {
+        errors.push(`position must be "long" or "short", got "${signal.position}"`);
+    }
     // ЗАЩИТА ОТ NaN/Infinity: currentPrice должна быть конечным числом
     if (!isFinite(currentPrice)) {
         errors.push(`currentPrice must be a finite number, got ${currentPrice} (${typeof currentPrice})`);
@@ -2111,10 +2123,13 @@ const GET_SIGNAL_FN = functoolsKit.trycatch(async (self) => {
 }, {
     defaultValue: null,
     fallback: (error) => {
-        backtest$1.loggerService.warn("ClientStrategy exception thrown", {
+        const message = "ClientStrategy exception thrown";
+        const payload = {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
-        });
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
         errorEmitter.next(error);
     },
 });
@@ -2805,7 +2820,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     // Moving towards TP
                     const tpDistance = signal.priceTakeProfit - signal.priceOpen;
                     const progressPercent = (currentDistance / tpDistance) * 100;
-                    await self.params.partial.profit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, self.params.execution.context.when);
+                    await self.params.partial.profit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, new Date(currentCandleTimestamp));
                     if (self.params.callbacks?.onPartialProfit) {
                         self.params.callbacks.onPartialProfit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest);
                     }
@@ -2814,7 +2829,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     // Moving towards SL
                     const slDistance = signal.priceOpen - signal.priceStopLoss;
                     const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
-                    await self.params.partial.loss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, self.params.execution.context.when);
+                    await self.params.partial.loss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, new Date(currentCandleTimestamp));
                     if (self.params.callbacks?.onPartialLoss) {
                         self.params.callbacks.onPartialLoss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest);
                     }
@@ -2827,7 +2842,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     // Moving towards TP
                     const tpDistance = signal.priceOpen - signal.priceTakeProfit;
                     const progressPercent = (currentDistance / tpDistance) * 100;
-                    await self.params.partial.profit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, self.params.execution.context.when);
+                    await self.params.partial.profit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, new Date(currentCandleTimestamp));
                     if (self.params.callbacks?.onPartialProfit) {
                         self.params.callbacks.onPartialProfit(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest);
                     }
@@ -2836,7 +2851,7 @@ const PROCESS_PENDING_SIGNAL_CANDLES_FN = async (self, signal, candles) => {
                     // Moving towards SL
                     const slDistance = signal.priceStopLoss - signal.priceOpen;
                     const progressPercent = (Math.abs(currentDistance) / slDistance) * 100;
-                    await self.params.partial.loss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, self.params.execution.context.when);
+                    await self.params.partial.loss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest, new Date(currentCandleTimestamp));
                     if (self.params.callbacks?.onPartialLoss) {
                         self.params.callbacks.onPartialLoss(self.params.execution.context.symbol, signal, averagePrice, Math.min(progressPercent, 100), self.params.execution.context.backtest);
                     }
@@ -3791,10 +3806,13 @@ const DO_VALIDATION_FN = functoolsKit.trycatch(async (validation, params) => {
 }, {
     defaultValue: false,
     fallback: (error) => {
-        backtest$1.loggerService.warn("ClientRisk exception thrown", {
+        const message = "ClientRisk exception thrown";
+        const payload = {
             error: functoolsKit.errorData(error),
             message: functoolsKit.getErrorMessage(error),
-        });
+        };
+        backtest$1.loggerService.warn(message, payload);
+        console.warn(message, payload);
         validationSubject.next(error);
     },
 });
@@ -3864,17 +3882,25 @@ class ClientRisk {
             };
             // Execute custom validations
             let isValid = true;
+            let rejectionNote = "N/A";
             if (this.params.validations) {
                 for (const validation of this.params.validations) {
                     if (functoolsKit.not(await DO_VALIDATION_FN(typeof validation === "function"
                         ? validation
                         : validation.validate, payload))) {
                         isValid = false;
+                        // Capture note from validation if available
+                        if (typeof validation !== "function" && validation.note) {
+                            rejectionNote = validation.note;
+                        }
                         break;
                     }
                 }
             }
             if (!isValid) {
+                // Call params.onRejected for riskSubject emission
+                await this.params.onRejected(params.symbol, params, riskMap.size, rejectionNote, Date.now());
+                // Call schema callbacks.onRejected if defined
                 if (this.params.callbacks?.onRejected) {
                     this.params.callbacks.onRejected(params.symbol, params);
                 }
@@ -3937,6 +3963,28 @@ class ClientRisk {
     }
 }
 
+/**
+ * Callback function for emitting risk rejection events to riskSubject.
+ *
+ * Called by ClientRisk when a signal is rejected due to risk validation failure.
+ * Emits RiskContract event to all subscribers.
+ *
+ * @param symbol - Trading pair symbol
+ * @param params - Risk check arguments
+ * @param activePositionCount - Number of active positions at rejection time
+ * @param comment - Rejection reason from validation note or "N/A"
+ * @param timestamp - Event timestamp in milliseconds
+ */
+const COMMIT_REJECTION_FN = async (symbol, params, activePositionCount, comment, timestamp) => await riskSubject.next({
+    symbol,
+    pendingSignal: params.pendingSignal,
+    strategyName: params.strategyName,
+    exchangeName: params.exchangeName,
+    currentPrice: params.currentPrice,
+    activePositionCount,
+    comment,
+    timestamp,
+});
 /**
  * Connection service routing risk operations to correct ClientRisk instance.
  *
@@ -3987,6 +4035,7 @@ class RiskConnectionService {
             return new ClientRisk({
                 ...schema,
                 logger: this.loggerService,
+                onRejected: COMMIT_REJECTION_FN,
             });
         });
         /**
@@ -3994,6 +4043,7 @@ class RiskConnectionService {
          *
          * Routes to appropriate ClientRisk instance based on provided context.
          * Validates portfolio drawdown, symbol exposure, position count, and daily loss limits.
+         * ClientRisk will emit riskSubject event via onRejected callback when signal is rejected.
          *
          * @param params - Risk check arguments (portfolio state, position details)
          * @param context - Execution context with risk name
@@ -5982,7 +6032,7 @@ function isUnsafe$3(value) {
     }
     return false;
 }
-const columns$4 = [
+const columns$5 = [
     {
         key: "signalId",
         label: "Signal ID",
@@ -6056,11 +6106,13 @@ const columns$4 = [
         format: (data) => new Date(data.closeTimestamp).toISOString(),
     },
 ];
+/** Maximum number of signals to store in backtest reports */
+const MAX_EVENTS$6 = 250;
 /**
  * Storage class for accumulating closed signals per strategy.
  * Maintains a list of all closed signals and provides methods to generate reports.
  */
-let ReportStorage$4 = class ReportStorage {
+let ReportStorage$5 = class ReportStorage {
     constructor() {
         /** Internal list of all closed signals for this strategy */
         this._signalList = [];
@@ -6071,7 +6123,11 @@ let ReportStorage$4 = class ReportStorage {
      * @param data - Closed signal data with PNL and close reason
      */
     addSignal(data) {
-        this._signalList.push(data);
+        this._signalList.unshift(data);
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._signalList.length > MAX_EVENTS$6) {
+            this._signalList.pop();
+        }
     }
     /**
      * Calculates statistical data from closed signals (Controller).
@@ -6154,9 +6210,9 @@ let ReportStorage$4 = class ReportStorage {
                 "No signals closed yet."
             ].join("\n");
         }
-        const header = columns$4.map((col) => col.label);
-        const separator = columns$4.map(() => "---");
-        const rows = this._signalList.map((closedSignal) => columns$4.map((col) => col.format(closedSignal)));
+        const header = columns$5.map((col) => col.label);
+        const separator = columns$5.map(() => "---");
+        const rows = this._signalList.map((closedSignal) => columns$5.map((col) => col.format(closedSignal)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map(row => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -6232,7 +6288,7 @@ class BacktestMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy pair.
          * Each symbol-strategy combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$4());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$5());
         /**
          * Processes tick events and accumulates closed signals.
          * Should be called from IStrategyCallbacks.onTick.
@@ -6403,7 +6459,7 @@ function isUnsafe$2(value) {
     }
     return false;
 }
-const columns$3 = [
+const columns$4 = [
     {
         key: "timestamp",
         label: "Timestamp",
@@ -6487,12 +6543,12 @@ const columns$3 = [
     },
 ];
 /** Maximum number of events to store in live trading reports */
-const MAX_EVENTS$3 = 250;
+const MAX_EVENTS$5 = 250;
 /**
  * Storage class for accumulating all tick events per strategy.
  * Maintains a chronological list of all events (idle, opened, active, closed).
  */
-let ReportStorage$3 = class ReportStorage {
+let ReportStorage$4 = class ReportStorage {
     constructor() {
         /** Internal list of all tick events for this strategy */
         this._eventList = [];
@@ -6519,9 +6575,9 @@ let ReportStorage$3 = class ReportStorage {
             return;
         }
         {
-            this._eventList.push(newEvent);
-            if (this._eventList.length > MAX_EVENTS$3) {
-                this._eventList.shift();
+            this._eventList.unshift(newEvent);
+            if (this._eventList.length > MAX_EVENTS$5) {
+                this._eventList.pop();
             }
         }
     }
@@ -6531,7 +6587,7 @@ let ReportStorage$3 = class ReportStorage {
      * @param data - Opened tick result
      */
     addOpenedEvent(data) {
-        this._eventList.push({
+        this._eventList.unshift({
             timestamp: data.signal.pendingAt,
             action: "opened",
             symbol: data.signal.symbol,
@@ -6544,12 +6600,13 @@ let ReportStorage$3 = class ReportStorage {
             stopLoss: data.signal.priceStopLoss,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$3) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$5) {
+            this._eventList.pop();
         }
     }
     /**
      * Adds an active event to the storage.
+     * Replaces the last active event with the same signalId.
      *
      * @param data - Active tick result
      */
@@ -6568,10 +6625,18 @@ let ReportStorage$3 = class ReportStorage {
             percentTp: data.percentTp,
             percentSl: data.percentSl,
         };
-        this._eventList.push(newEvent);
+        // Find the last active event with the same signalId
+        const lastActiveIndex = this._eventList.findLastIndex((event) => event.action === "active" && event.signalId === data.signal.id);
+        // Replace the last active event with the same signalId
+        if (lastActiveIndex !== -1) {
+            this._eventList[lastActiveIndex] = newEvent;
+            return;
+        }
+        // If no previous active event found, add new event
+        this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$3) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$5) {
+            this._eventList.pop();
         }
     }
     /**
@@ -6597,10 +6662,10 @@ let ReportStorage$3 = class ReportStorage {
             closeReason: data.closeReason,
             duration: durationMin,
         };
-        this._eventList.push(newEvent);
+        this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$3) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$5) {
+            this._eventList.pop();
         }
     }
     /**
@@ -6699,9 +6764,9 @@ let ReportStorage$3 = class ReportStorage {
                 "No events recorded yet."
             ].join("\n");
         }
-        const header = columns$3.map((col) => col.label);
-        const separator = columns$3.map(() => "---");
-        const rows = this._eventList.map((event) => columns$3.map((col) => col.format(event)));
+        const header = columns$4.map((col) => col.label);
+        const separator = columns$4.map(() => "---");
+        const rows = this._eventList.map((event) => columns$4.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map(row => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -6780,7 +6845,7 @@ class LiveMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy pair.
          * Each symbol-strategy combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$3());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$4());
         /**
          * Processes tick events and accumulates all event types.
          * Should be called from IStrategyCallbacks.onTick.
@@ -6943,7 +7008,7 @@ class LiveMarkdownService {
     }
 }
 
-const columns$2 = [
+const columns$3 = [
     {
         key: "timestamp",
         label: "Timestamp",
@@ -7001,12 +7066,12 @@ const columns$2 = [
     },
 ];
 /** Maximum number of events to store in schedule reports */
-const MAX_EVENTS$2 = 250;
+const MAX_EVENTS$4 = 250;
 /**
  * Storage class for accumulating scheduled signal events per strategy.
  * Maintains a chronological list of scheduled and cancelled events.
  */
-let ReportStorage$2 = class ReportStorage {
+let ReportStorage$3 = class ReportStorage {
     constructor() {
         /** Internal list of all scheduled events for this strategy */
         this._eventList = [];
@@ -7017,7 +7082,7 @@ let ReportStorage$2 = class ReportStorage {
      * @param data - Scheduled tick result
      */
     addScheduledEvent(data) {
-        this._eventList.push({
+        this._eventList.unshift({
             timestamp: data.signal.scheduledAt,
             action: "scheduled",
             symbol: data.signal.symbol,
@@ -7030,8 +7095,35 @@ let ReportStorage$2 = class ReportStorage {
             stopLoss: data.signal.priceStopLoss,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$2) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$4) {
+            this._eventList.pop();
+        }
+    }
+    /**
+     * Adds an opened event to the storage.
+     *
+     * @param data - Opened tick result
+     */
+    addOpenedEvent(data) {
+        const durationMs = data.signal.pendingAt - data.signal.scheduledAt;
+        const durationMin = Math.round(durationMs / 60000);
+        const newEvent = {
+            timestamp: data.signal.pendingAt,
+            action: "opened",
+            symbol: data.signal.symbol,
+            signalId: data.signal.id,
+            position: data.signal.position,
+            note: data.signal.note,
+            currentPrice: data.currentPrice,
+            priceOpen: data.signal.priceOpen,
+            takeProfit: data.signal.priceTakeProfit,
+            stopLoss: data.signal.priceStopLoss,
+            duration: durationMin,
+        };
+        this._eventList.unshift(newEvent);
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._eventList.length > MAX_EVENTS$4) {
+            this._eventList.pop();
         }
     }
     /**
@@ -7056,10 +7148,10 @@ let ReportStorage$2 = class ReportStorage {
             closeTimestamp: data.closeTimestamp,
             duration: durationMin,
         };
-        this._eventList.push(newEvent);
+        this._eventList.unshift(newEvent);
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$2) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$4) {
+            this._eventList.pop();
         }
     }
     /**
@@ -7073,29 +7165,44 @@ let ReportStorage$2 = class ReportStorage {
                 eventList: [],
                 totalEvents: 0,
                 totalScheduled: 0,
+                totalOpened: 0,
                 totalCancelled: 0,
                 cancellationRate: null,
+                activationRate: null,
                 avgWaitTime: null,
+                avgActivationTime: null,
             };
         }
         const scheduledEvents = this._eventList.filter((e) => e.action === "scheduled");
+        const openedEvents = this._eventList.filter((e) => e.action === "opened");
         const cancelledEvents = this._eventList.filter((e) => e.action === "cancelled");
         const totalScheduled = scheduledEvents.length;
+        const totalOpened = openedEvents.length;
         const totalCancelled = cancelledEvents.length;
         // Calculate cancellation rate
         const cancellationRate = totalScheduled > 0 ? (totalCancelled / totalScheduled) * 100 : null;
+        // Calculate activation rate
+        const activationRate = totalScheduled > 0 ? (totalOpened / totalScheduled) * 100 : null;
         // Calculate average wait time for cancelled signals
         const avgWaitTime = totalCancelled > 0
             ? cancelledEvents.reduce((sum, e) => sum + (e.duration || 0), 0) /
                 totalCancelled
             : null;
+        // Calculate average activation time for opened signals
+        const avgActivationTime = totalOpened > 0
+            ? openedEvents.reduce((sum, e) => sum + (e.duration || 0), 0) /
+                totalOpened
+            : null;
         return {
             eventList: this._eventList,
             totalEvents: this._eventList.length,
             totalScheduled,
+            totalOpened,
             totalCancelled,
             cancellationRate,
+            activationRate,
             avgWaitTime,
+            avgActivationTime,
         };
     }
     /**
@@ -7113,9 +7220,9 @@ let ReportStorage$2 = class ReportStorage {
                 "No scheduled signals recorded yet."
             ].join("\n");
         }
-        const header = columns$2.map((col) => col.label);
-        const separator = columns$2.map(() => "---");
-        const rows = this._eventList.map((event) => columns$2.map((col) => col.format(event)));
+        const header = columns$3.map((col) => col.label);
+        const separator = columns$3.map(() => "---");
+        const rows = this._eventList.map((event) => columns$3.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -7125,8 +7232,11 @@ let ReportStorage$2 = class ReportStorage {
             "",
             `**Total events:** ${stats.totalEvents}`,
             `**Scheduled signals:** ${stats.totalScheduled}`,
+            `**Opened signals:** ${stats.totalOpened}`,
             `**Cancelled signals:** ${stats.totalCancelled}`,
+            `**Activation rate:** ${stats.activationRate === null ? "N/A" : `${stats.activationRate.toFixed(2)}% (higher is better)`}`,
             `**Cancellation rate:** ${stats.cancellationRate === null ? "N/A" : `${stats.cancellationRate.toFixed(2)}% (lower is better)`}`,
+            `**Average activation time:** ${stats.avgActivationTime === null ? "N/A" : `${stats.avgActivationTime.toFixed(2)} minutes`}`,
             `**Average wait time (cancelled):** ${stats.avgWaitTime === null ? "N/A" : `${stats.avgWaitTime.toFixed(2)} minutes`}`
         ].join("\n");
     }
@@ -7180,12 +7290,12 @@ class ScheduleMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy pair.
          * Each symbol-strategy combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$2());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$3());
         /**
-         * Processes tick events and accumulates scheduled/cancelled events.
-         * Should be called from signalLiveEmitter subscription.
+         * Processes tick events and accumulates scheduled/opened/cancelled events.
+         * Should be called from signalEmitter subscription.
          *
-         * Processes only scheduled and cancelled event types.
+         * Processes only scheduled, opened and cancelled event types.
          *
          * @param data - Tick result from strategy execution
          *
@@ -7203,6 +7313,13 @@ class ScheduleMarkdownService {
             if (data.action === "scheduled") {
                 storage.addScheduledEvent(data);
             }
+            else if (data.action === "opened") {
+                // Check if this opened signal was previously scheduled
+                // by checking if signal has scheduledAt != pendingAt
+                if (data.signal.scheduledAt !== data.signal.pendingAt) {
+                    storage.addOpenedEvent(data);
+                }
+            }
             else if (data.action === "cancelled") {
                 storage.addCancelledEvent(data);
             }
@@ -7340,7 +7457,7 @@ function percentile(sortedArray, p) {
     return sortedArray[Math.max(0, index)];
 }
 /** Maximum number of performance events to store per strategy */
-const MAX_EVENTS$1 = 10000;
+const MAX_EVENTS$3 = 10000;
 /**
  * Storage class for accumulating performance metrics per strategy.
  * Maintains a list of all performance events and provides aggregated statistics.
@@ -7356,10 +7473,10 @@ class PerformanceStorage {
      * @param event - Performance event with timing data
      */
     addEvent(event) {
-        this._events.push(event);
+        this._events.unshift(event);
         // Trim queue if exceeded MAX_EVENTS (keep most recent)
-        if (this._events.length > MAX_EVENTS$1) {
-            this._events.shift();
+        if (this._events.length > MAX_EVENTS$3) {
+            this._events.pop();
         }
     }
     /**
@@ -7825,7 +7942,7 @@ const pnlColumns = [
  * Storage class for accumulating walker results.
  * Maintains a list of all strategy results and provides methods to generate reports.
  */
-let ReportStorage$1 = class ReportStorage {
+let ReportStorage$2 = class ReportStorage {
     constructor(walkerName) {
         this.walkerName = walkerName;
         /** Walker metadata (set from first addResult call) */
@@ -7843,17 +7960,13 @@ let ReportStorage$1 = class ReportStorage {
      * @param data - Walker contract with strategy result
      */
     addResult(data) {
-        {
-            this._bestMetric = data.bestMetric;
-            this._bestStrategy = data.bestStrategy;
-            this._totalStrategies = data.totalStrategies;
-        }
-        // Update best stats only if this strategy is the current best
+        this._totalStrategies = data.totalStrategies;
+        this._bestMetric = data.bestMetric;
+        this._bestStrategy = data.bestStrategy;
         if (data.strategyName === data.bestStrategy) {
             this._bestStats = data.stats;
         }
-        // Add strategy result to comparison list
-        this._strategyResults.push({
+        this._strategyResults.unshift({
             strategyName: data.strategyName,
             stats: data.stats,
             metricValue: data.metricValue,
@@ -8037,7 +8150,7 @@ class WalkerMarkdownService {
          * Memoized function to get or create ReportStorage for a walker.
          * Each walker gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$1(walkerName));
+        this.getStorage = functoolsKit.memoize(([walkerName]) => `${walkerName}`, (walkerName) => new ReportStorage$2(walkerName));
         /**
          * Processes walker progress events and accumulates strategy results.
          * Should be called from walkerEmitter.
@@ -8208,7 +8321,7 @@ function isUnsafe(value) {
     }
     return false;
 }
-const columns$1 = [
+const columns$2 = [
     {
         key: "symbol",
         label: "Symbol",
@@ -8270,6 +8383,8 @@ const columns$1 = [
         format: (data) => data.totalTrades.toString(),
     },
 ];
+/** Maximum number of signals to store per symbol in heatmap reports */
+const MAX_EVENTS$2 = 250;
 /**
  * Storage class for accumulating closed signals per strategy and generating heatmap.
  * Maintains symbol-level statistics and provides portfolio-wide metrics.
@@ -8289,7 +8404,12 @@ class HeatmapStorage {
         if (!this.symbolData.has(symbol)) {
             this.symbolData.set(symbol, []);
         }
-        this.symbolData.get(symbol).push(data);
+        const signals = this.symbolData.get(symbol);
+        signals.unshift(data);
+        // Trim queue if exceeded MAX_EVENTS per symbol
+        if (signals.length > MAX_EVENTS$2) {
+            signals.pop();
+        }
     }
     /**
      * Calculates statistics for a single symbol.
@@ -8508,9 +8628,9 @@ class HeatmapStorage {
                 "*No data available*"
             ].join("\n");
         }
-        const header = columns$1.map((col) => col.label);
-        const separator = columns$1.map(() => "---");
-        const rows = data.symbols.map((row) => columns$1.map((col) => col.format(row)));
+        const header = columns$2.map((col) => col.label);
+        const separator = columns$2.map(() => "---");
+        const rows = data.symbols.map((row) => columns$2.map((col) => col.format(row)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -10548,7 +10668,7 @@ const HANDLE_PROFIT_FN = async (symbol, data, currentPrice, revenuePercent, back
                 revenuePercent,
                 backtest,
             });
-            await self.params.onProfit(symbol, data, currentPrice, level, backtest, when.getTime());
+            await self.params.onProfit(symbol, data.strategyName, data.exchangeName, data, currentPrice, level, backtest, when.getTime());
         }
     }
     if (shouldPersist) {
@@ -10595,7 +10715,7 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
                 lossPercent,
                 backtest,
             });
-            await self.params.onLoss(symbol, data, currentPrice, level, backtest, when.getTime());
+            await self.params.onLoss(symbol, data.strategyName, data.exchangeName, data, currentPrice, level, backtest, when.getTime());
         }
     }
     if (shouldPersist) {
@@ -10866,6 +10986,7 @@ class ClientPartial {
             symbol,
             data,
             priceClose,
+            backtest,
         });
         if (this._states === NEED_FETCH) {
             throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
@@ -10882,14 +11003,18 @@ class ClientPartial {
  * Emits PartialProfitContract event to all subscribers.
  *
  * @param symbol - Trading pair symbol
+ * @param strategyName - Strategy name that generated this signal
+ * @param exchangeName - Exchange name where this signal is being executed
  * @param data - Signal row data
  * @param currentPrice - Current market price
  * @param level - Profit level reached
  * @param backtest - True if backtest mode
  * @param timestamp - Event timestamp in milliseconds
  */
-const COMMIT_PROFIT_FN = async (symbol, data, currentPrice, level, backtest, timestamp) => await partialProfitSubject.next({
+const COMMIT_PROFIT_FN = async (symbol, strategyName, exchangeName, data, currentPrice, level, backtest, timestamp) => await partialProfitSubject.next({
     symbol,
+    strategyName,
+    exchangeName,
     data,
     currentPrice,
     level,
@@ -10903,14 +11028,18 @@ const COMMIT_PROFIT_FN = async (symbol, data, currentPrice, level, backtest, tim
  * Emits PartialLossContract event to all subscribers.
  *
  * @param symbol - Trading pair symbol
+ * @param strategyName - Strategy name that generated this signal
+ * @param exchangeName - Exchange name where this signal is being executed
  * @param data - Signal row data
  * @param currentPrice - Current market price
  * @param level - Loss level reached
  * @param backtest - True if backtest mode
  * @param timestamp - Event timestamp in milliseconds
  */
-const COMMIT_LOSS_FN = async (symbol, data, currentPrice, level, backtest, timestamp) => await partialLossSubject.next({
+const COMMIT_LOSS_FN = async (symbol, strategyName, exchangeName, data, currentPrice, level, backtest, timestamp) => await partialLossSubject.next({
     symbol,
+    strategyName,
+    exchangeName,
     data,
     currentPrice,
     level,
@@ -11056,7 +11185,7 @@ class PartialConnectionService {
     }
 }
 
-const columns = [
+const columns$1 = [
     {
         key: "action",
         label: "Action",
@@ -11104,12 +11233,12 @@ const columns = [
     },
 ];
 /** Maximum number of events to store in partial reports */
-const MAX_EVENTS = 250;
+const MAX_EVENTS$1 = 250;
 /**
  * Storage class for accumulating partial profit/loss events per symbol-strategy pair.
  * Maintains a chronological list of profit and loss level events.
  */
-class ReportStorage {
+let ReportStorage$1 = class ReportStorage {
     constructor() {
         /** Internal list of all partial events for this symbol */
         this._eventList = [];
@@ -11123,7 +11252,7 @@ class ReportStorage {
      * @param backtest - True if backtest mode
      */
     addProfitEvent(data, currentPrice, level, backtest, timestamp) {
-        this._eventList.push({
+        this._eventList.unshift({
             timestamp,
             action: "profit",
             symbol: data.symbol,
@@ -11135,8 +11264,8 @@ class ReportStorage {
             backtest,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$1) {
+            this._eventList.pop();
         }
     }
     /**
@@ -11148,7 +11277,7 @@ class ReportStorage {
      * @param backtest - True if backtest mode
      */
     addLossEvent(data, currentPrice, level, backtest, timestamp) {
-        this._eventList.push({
+        this._eventList.unshift({
             timestamp,
             action: "loss",
             symbol: data.symbol,
@@ -11160,8 +11289,8 @@ class ReportStorage {
             backtest,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$1) {
+            this._eventList.pop();
         }
     }
     /**
@@ -11203,9 +11332,9 @@ class ReportStorage {
                 "No partial profit/loss events recorded yet."
             ].join("\n");
         }
-        const header = columns.map((col) => col.label);
-        const separator = columns.map(() => "---");
-        const rows = this._eventList.map((event) => columns.map((col) => col.format(event)));
+        const header = columns$1.map((col) => col.label);
+        const separator = columns$1.map(() => "---");
+        const rows = this._eventList.map((event) => columns$1.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -11239,7 +11368,7 @@ class ReportStorage {
             console.error(`Failed to save markdown report:`, error);
         }
     }
-}
+};
 /**
  * Service for generating and saving partial profit/loss markdown reports.
  *
@@ -11269,7 +11398,7 @@ class PartialMarkdownService {
          * Memoized function to get or create ReportStorage for a symbol-strategy pair.
          * Each symbol-strategy combination gets its own isolated storage instance.
          */
-        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage());
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage$1());
         /**
          * Processes profit events and accumulates them.
          * Should be called from partialProfitSubject subscription.
@@ -11579,7 +11708,7 @@ class PartialGlobalService {
  * Warning threshold for message size in kilobytes.
  * Messages exceeding this size trigger console warnings.
  */
-const WARN_KB = 100;
+const WARN_KB = 20;
 /**
  * Internal function for dumping signal data to markdown files.
  * Creates a directory structure with system prompts, user messages, and LLM output.
@@ -11841,35 +11970,382 @@ class ConfigValidationService {
     }
 }
 
-{
-    provide(TYPES.loggerService, () => new LoggerService());
-}
-{
-    provide(TYPES.executionContextService, () => new ExecutionContextService());
-    provide(TYPES.methodContextService, () => new MethodContextService());
-}
-{
-    provide(TYPES.exchangeConnectionService, () => new ExchangeConnectionService());
-    provide(TYPES.strategyConnectionService, () => new StrategyConnectionService());
-    provide(TYPES.frameConnectionService, () => new FrameConnectionService());
-    provide(TYPES.sizingConnectionService, () => new SizingConnectionService());
-    provide(TYPES.riskConnectionService, () => new RiskConnectionService());
-    provide(TYPES.optimizerConnectionService, () => new OptimizerConnectionService());
-    provide(TYPES.partialConnectionService, () => new PartialConnectionService());
-}
-{
-    provide(TYPES.exchangeSchemaService, () => new ExchangeSchemaService());
-    provide(TYPES.strategySchemaService, () => new StrategySchemaService());
-    provide(TYPES.frameSchemaService, () => new FrameSchemaService());
-    provide(TYPES.walkerSchemaService, () => new WalkerSchemaService());
-    provide(TYPES.sizingSchemaService, () => new SizingSchemaService());
-    provide(TYPES.riskSchemaService, () => new RiskSchemaService());
-    provide(TYPES.optimizerSchemaService, () => new OptimizerSchemaService());
+const columns = [
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+    },
+    {
+        key: "strategyName",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.pendingSignal.id || "N/A",
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.pendingSignal.position.toUpperCase(),
+    },
+    {
+        key: "exchangeName",
+        label: "Exchange",
+        format: (data) => data.exchangeName,
+    },
+    {
+        key: "openPrice",
+        label: "Open Price",
+        format: (data) => data.pendingSignal.priceOpen !== undefined
+            ? `${data.pendingSignal.priceOpen.toFixed(8)} USD`
+            : "N/A",
+    },
+    {
+        key: "takeProfit",
+        label: "Take Profit",
+        format: (data) => data.pendingSignal.priceTakeProfit !== undefined
+            ? `${data.pendingSignal.priceTakeProfit.toFixed(8)} USD`
+            : "N/A",
+    },
+    {
+        key: "stopLoss",
+        label: "Stop Loss",
+        format: (data) => data.pendingSignal.priceStopLoss !== undefined
+            ? `${data.pendingSignal.priceStopLoss.toFixed(8)} USD`
+            : "N/A",
+    },
+    {
+        key: "currentPrice",
+        label: "Current Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+    },
+    {
+        key: "activePositionCount",
+        label: "Active Positions",
+        format: (data) => data.activePositionCount.toString(),
+    },
+    {
+        key: "comment",
+        label: "Reason",
+        format: (data) => data.comment,
+    },
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+    },
+];
+/** Maximum number of events to store in risk reports */
+const MAX_EVENTS = 250;
+/**
+ * Storage class for accumulating risk rejection events per symbol-strategy pair.
+ * Maintains a chronological list of rejected signals due to risk limits.
+ */
+class ReportStorage {
+    constructor() {
+        /** Internal list of all risk rejection events for this symbol */
+        this._eventList = [];
+    }
+    /**
+     * Adds a risk rejection event to the storage.
+     *
+     * @param event - Risk rejection event data
+     */
+    addRejectionEvent(event) {
+        this._eventList.unshift(event);
+        // Trim queue if exceeded MAX_EVENTS
+        if (this._eventList.length > MAX_EVENTS) {
+            this._eventList.pop();
+        }
+    }
+    /**
+     * Calculates statistical data from risk rejection events (Controller).
+     *
+     * @returns Statistical data (empty object if no events)
+     */
+    async getData() {
+        if (this._eventList.length === 0) {
+            return {
+                eventList: [],
+                totalRejections: 0,
+                bySymbol: {},
+                byStrategy: {},
+            };
+        }
+        const bySymbol = {};
+        const byStrategy = {};
+        for (const event of this._eventList) {
+            bySymbol[event.symbol] = (bySymbol[event.symbol] || 0) + 1;
+            byStrategy[event.strategyName] = (byStrategy[event.strategyName] || 0) + 1;
+        }
+        return {
+            eventList: this._eventList,
+            totalRejections: this._eventList.length,
+            bySymbol,
+            byStrategy,
+        };
+    }
+    /**
+     * Generates markdown report with all risk rejection events for a symbol-strategy pair (View).
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy name
+     * @returns Markdown formatted report with all events
+     */
+    async getReport(symbol, strategyName) {
+        const stats = await this.getData();
+        if (stats.totalRejections === 0) {
+            return [
+                `# Risk Rejection Report: ${symbol}:${strategyName}`,
+                "",
+                "No risk rejections recorded yet.",
+            ].join("\n");
+        }
+        const header = columns.map((col) => col.label);
+        const separator = columns.map(() => "---");
+        const rows = this._eventList.map((event) => columns.map((col) => col.format(event)));
+        const tableData = [header, separator, ...rows];
+        const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
+        return [
+            `# Risk Rejection Report: ${symbol}:${strategyName}`,
+            "",
+            table,
+            "",
+            `**Total rejections:** ${stats.totalRejections}`,
+            "",
+            "## Rejections by Symbol",
+            ...Object.entries(stats.bySymbol).map(([sym, count]) => `- ${sym}: ${count}`),
+            "",
+            "## Rejections by Strategy",
+            ...Object.entries(stats.byStrategy).map(([strat, count]) => `- ${strat}: ${count}`),
+        ].join("\n");
+    }
+    /**
+     * Saves symbol-strategy report to disk.
+     *
+     * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy name
+     * @param path - Directory path to save report (default: "./dump/risk")
+     */
+    async dump(symbol, strategyName, path$1 = "./dump/risk") {
+        const markdown = await this.getReport(symbol, strategyName);
+        try {
+            const dir = path.join(process.cwd(), path$1);
+            await fs.mkdir(dir, { recursive: true });
+            const filename = `${symbol}_${strategyName}.md`;
+            const filepath = path.join(dir, filename);
+            await fs.writeFile(filepath, markdown, "utf-8");
+            console.log(`Risk rejection report saved: ${filepath}`);
+        }
+        catch (error) {
+            console.error(`Failed to save markdown report:`, error);
+        }
+    }
 }
-{
-    provide(TYPES.exchangeCoreService, () => new ExchangeCoreService());
-    provide(TYPES.strategyCoreService, () => new StrategyCoreService());
-    provide(TYPES.frameCoreService, () => new FrameCoreService());
+/**
+ * Service for generating and saving risk rejection markdown reports.
+ *
+ * Features:
+ * - Listens to risk rejection events via riskSubject
+ * - Accumulates all rejection events per symbol-strategy pair
+ * - Generates markdown tables with detailed rejection information
+ * - Provides statistics (total rejections, by symbol, by strategy)
+ * - Saves reports to disk in dump/risk/{symbol}_{strategyName}.md
+ *
+ * @example
+ * ```typescript
+ * const service = new RiskMarkdownService();
+ *
+ * // Service automatically subscribes to subjects on init
+ * // No manual callback setup needed
+ *
+ * // Later: generate and save report
+ * await service.dump("BTCUSDT", "my-strategy");
+ * ```
+ */
+class RiskMarkdownService {
+    constructor() {
+        /** Logger service for debug output */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Memoized function to get or create ReportStorage for a symbol-strategy pair.
+         * Each symbol-strategy combination gets its own isolated storage instance.
+         */
+        this.getStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, () => new ReportStorage());
+        /**
+         * Processes risk rejection events and accumulates them.
+         * Should be called from riskSubject subscription.
+         *
+         * @param data - Risk rejection event data
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         * // Service automatically subscribes in init()
+         * ```
+         */
+        this.tickRejection = async (data) => {
+            this.loggerService.log("riskMarkdownService tickRejection", {
+                data,
+            });
+            const storage = this.getStorage(data.symbol, data.strategyName);
+            storage.addRejectionEvent(data);
+        };
+        /**
+         * Gets statistical data from all risk rejection events for a symbol-strategy pair.
+         * Delegates to ReportStorage.getData().
+         *
+         * @param symbol - Trading pair symbol to get data for
+         * @param strategyName - Strategy name to get data for
+         * @returns Statistical data object with all metrics
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         * const stats = await service.getData("BTCUSDT", "my-strategy");
+         * console.log(stats.totalRejections, stats.bySymbol);
+         * ```
+         */
+        this.getData = async (symbol, strategyName) => {
+            this.loggerService.log("riskMarkdownService getData", {
+                symbol,
+                strategyName,
+            });
+            const storage = this.getStorage(symbol, strategyName);
+            return storage.getData();
+        };
+        /**
+         * Generates markdown report with all risk rejection events for a symbol-strategy pair.
+         * Delegates to ReportStorage.getReport().
+         *
+         * @param symbol - Trading pair symbol to generate report for
+         * @param strategyName - Strategy name to generate report for
+         * @returns Markdown formatted report string with table of all events
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         * const markdown = await service.getReport("BTCUSDT", "my-strategy");
+         * console.log(markdown);
+         * ```
+         */
+        this.getReport = async (symbol, strategyName) => {
+            this.loggerService.log("riskMarkdownService getReport", {
+                symbol,
+                strategyName,
+            });
+            const storage = this.getStorage(symbol, strategyName);
+            return storage.getReport(symbol, strategyName);
+        };
+        /**
+         * Saves symbol-strategy report to disk.
+         * Creates directory if it doesn't exist.
+         * Delegates to ReportStorage.dump().
+         *
+         * @param symbol - Trading pair symbol to save report for
+         * @param strategyName - Strategy name to save report for
+         * @param path - Directory path to save report (default: "./dump/risk")
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         *
+         * // Save to default path: ./dump/risk/BTCUSDT_my-strategy.md
+         * await service.dump("BTCUSDT", "my-strategy");
+         *
+         * // Save to custom path: ./custom/path/BTCUSDT_my-strategy.md
+         * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
+         * ```
+         */
+        this.dump = async (symbol, strategyName, path = "./dump/risk") => {
+            this.loggerService.log("riskMarkdownService dump", {
+                symbol,
+                strategyName,
+                path,
+            });
+            const storage = this.getStorage(symbol, strategyName);
+            await storage.dump(symbol, strategyName, path);
+        };
+        /**
+         * Clears accumulated event data from storage.
+         * If ctx is provided, clears only that specific symbol-strategy pair's data.
+         * If nothing is provided, clears all data.
+         *
+         * @param ctx - Optional context with symbol and strategyName
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         *
+         * // Clear specific symbol-strategy pair
+         * await service.clear({ symbol: "BTCUSDT", strategyName: "my-strategy" });
+         *
+         * // Clear all data
+         * await service.clear();
+         * ```
+         */
+        this.clear = async (ctx) => {
+            this.loggerService.log("riskMarkdownService clear", {
+                ctx,
+            });
+            if (ctx) {
+                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                this.getStorage.clear(key);
+            }
+            else {
+                this.getStorage.clear();
+            }
+        };
+        /**
+         * Initializes the service by subscribing to risk rejection events.
+         * Uses singleshot to ensure initialization happens only once.
+         * Automatically called on first use.
+         *
+         * @example
+         * ```typescript
+         * const service = new RiskMarkdownService();
+         * await service.init(); // Subscribe to rejection events
+         * ```
+         */
+        this.init = functoolsKit.singleshot(async () => {
+            this.loggerService.log("riskMarkdownService init");
+            riskSubject.subscribe(this.tickRejection);
+        });
+    }
+}
+
+{
+    provide(TYPES.loggerService, () => new LoggerService());
+}
+{
+    provide(TYPES.executionContextService, () => new ExecutionContextService());
+    provide(TYPES.methodContextService, () => new MethodContextService());
+}
+{
+    provide(TYPES.exchangeConnectionService, () => new ExchangeConnectionService());
+    provide(TYPES.strategyConnectionService, () => new StrategyConnectionService());
+    provide(TYPES.frameConnectionService, () => new FrameConnectionService());
+    provide(TYPES.sizingConnectionService, () => new SizingConnectionService());
+    provide(TYPES.riskConnectionService, () => new RiskConnectionService());
+    provide(TYPES.optimizerConnectionService, () => new OptimizerConnectionService());
+    provide(TYPES.partialConnectionService, () => new PartialConnectionService());
+}
+{
+    provide(TYPES.exchangeSchemaService, () => new ExchangeSchemaService());
+    provide(TYPES.strategySchemaService, () => new StrategySchemaService());
+    provide(TYPES.frameSchemaService, () => new FrameSchemaService());
+    provide(TYPES.walkerSchemaService, () => new WalkerSchemaService());
+    provide(TYPES.sizingSchemaService, () => new SizingSchemaService());
+    provide(TYPES.riskSchemaService, () => new RiskSchemaService());
+    provide(TYPES.optimizerSchemaService, () => new OptimizerSchemaService());
+}
+{
+    provide(TYPES.exchangeCoreService, () => new ExchangeCoreService());
+    provide(TYPES.strategyCoreService, () => new StrategyCoreService());
+    provide(TYPES.frameCoreService, () => new FrameCoreService());
 }
 {
     provide(TYPES.sizingGlobalService, () => new SizingGlobalService());
@@ -11901,6 +12377,7 @@ class ConfigValidationService {
     provide(TYPES.heatMarkdownService, () => new HeatMarkdownService());
     provide(TYPES.partialMarkdownService, () => new PartialMarkdownService());
     provide(TYPES.outlineMarkdownService, () => new OutlineMarkdownService());
+    provide(TYPES.riskMarkdownService, () => new RiskMarkdownService());
 }
 {
     provide(TYPES.exchangeValidationService, () => new ExchangeValidationService());
@@ -11976,6 +12453,7 @@ const markdownServices = {
     heatMarkdownService: inject(TYPES.heatMarkdownService),
     partialMarkdownService: inject(TYPES.partialMarkdownService),
     outlineMarkdownService: inject(TYPES.outlineMarkdownService),
+    riskMarkdownService: inject(TYPES.riskMarkdownService),
 };
 const validationServices = {
     exchangeValidationService: inject(TYPES.exchangeValidationService),
@@ -12750,6 +13228,8 @@ const LISTEN_PARTIAL_PROFIT_METHOD_NAME = "event.listenPartialProfit";
 const LISTEN_PARTIAL_PROFIT_ONCE_METHOD_NAME = "event.listenPartialProfitOnce";
 const LISTEN_PARTIAL_LOSS_METHOD_NAME = "event.listenPartialLoss";
 const LISTEN_PARTIAL_LOSS_ONCE_METHOD_NAME = "event.listenPartialLossOnce";
+const LISTEN_RISK_METHOD_NAME = "event.listenRisk";
+const LISTEN_RISK_ONCE_METHOD_NAME = "event.listenRiskOnce";
 /**
  * Subscribes to all signal events with queued async processing.
  *
@@ -13548,6 +14028,75 @@ function listenPartialLossOnce(filterFn, fn) {
     backtest$1.loggerService.log(LISTEN_PARTIAL_LOSS_ONCE_METHOD_NAME);
     return partialLossSubject.filter(filterFn).once(fn);
 }
+/**
+ * Subscribes to risk rejection events with queued async processing.
+ *
+ * Emits ONLY when a signal is rejected due to risk validation failure.
+ * Does not emit for allowed signals (prevents spam).
+ * Events are processed sequentially in order received, even if callback is async.
+ * Uses queued wrapper to prevent concurrent execution of the callback.
+ *
+ * @param fn - Callback function to handle risk rejection events
+ * @returns Unsubscribe function to stop listening to events
+ *
+ * @example
+ * ```typescript
+ * import { listenRisk } from "./function/event";
+ *
+ * const unsubscribe = listenRisk((event) => {
+ *   console.log(`[RISK REJECTED] Signal for ${event.symbol}`);
+ *   console.log(`Strategy: ${event.strategyName}`);
+ *   console.log(`Position: ${event.pendingSignal.position}`);
+ *   console.log(`Active positions: ${event.activePositionCount}`);
+ *   console.log(`Reason: ${event.comment}`);
+ *   console.log(`Price: ${event.currentPrice}`);
+ * });
+ *
+ * // Later: stop listening
+ * unsubscribe();
+ * ```
+ */
+function listenRisk(fn) {
+    backtest$1.loggerService.log(LISTEN_RISK_METHOD_NAME);
+    return riskSubject.subscribe(functoolsKit.queued(async (event) => fn(event)));
+}
+/**
+ * Subscribes to filtered risk rejection events with one-time execution.
+ *
+ * Listens for events matching the filter predicate, then executes callback once
+ * and automatically unsubscribes. Useful for waiting for specific risk rejection conditions.
+ *
+ * @param filterFn - Predicate to filter which events trigger the callback
+ * @param fn - Callback function to handle the filtered event (called only once)
+ * @returns Unsubscribe function to cancel the listener before it fires
+ *
+ * @example
+ * ```typescript
+ * import { listenRiskOnce } from "./function/event";
+ *
+ * // Wait for first risk rejection on BTCUSDT
+ * listenRiskOnce(
+ *   (event) => event.symbol === "BTCUSDT",
+ *   (event) => {
+ *     console.log("BTCUSDT signal rejected!");
+ *     console.log("Reason:", event.comment);
+ *   }
+ * );
+ *
+ * // Wait for rejection due to position limit
+ * const cancel = listenRiskOnce(
+ *   (event) => event.comment.includes("Max") && event.activePositionCount >= 3,
+ *   (event) => console.log("Position limit reached:", event.activePositionCount)
+ * );
+ *
+ * // Cancel if needed before event fires
+ * cancel();
+ * ```
+ */
+function listenRiskOnce(filterFn, fn) {
+    backtest$1.loggerService.log(LISTEN_RISK_ONCE_METHOD_NAME);
+    return riskSubject.filter(filterFn).once(fn);
+}
 
 const GET_CANDLES_METHOD_NAME = "exchange.getCandles";
 const GET_AVERAGE_PRICE_METHOD_NAME = "exchange.getAveragePrice";
@@ -16172,6 +16721,186 @@ class ConstantUtils {
  */
 const Constant = new ConstantUtils();
 
+const RISK_METHOD_NAME_GET_DATA = "RiskUtils.getData";
+const RISK_METHOD_NAME_GET_REPORT = "RiskUtils.getReport";
+const RISK_METHOD_NAME_DUMP = "RiskUtils.dump";
+/**
+ * Utility class for accessing risk rejection reports and statistics.
+ *
+ * Provides static-like methods (via singleton instance) to retrieve data
+ * accumulated by RiskMarkdownService from risk rejection events.
+ *
+ * Features:
+ * - Statistical data extraction (total rejections count, by symbol, by strategy)
+ * - Markdown report generation with event tables
+ * - File export to disk
+ *
+ * Data source:
+ * - RiskMarkdownService listens to riskSubject
+ * - Accumulates rejection events in ReportStorage (max 250 events per symbol-strategy pair)
+ * - Events include: timestamp, symbol, strategyName, position, exchangeName, price, activePositionCount, comment
+ *
+ * @example
+ * ```typescript
+ * import { Risk } from "./classes/Risk";
+ *
+ * // Get statistical data for BTCUSDT:my-strategy
+ * const stats = await Risk.getData("BTCUSDT", "my-strategy");
+ * console.log(`Total rejections: ${stats.totalRejections}`);
+ * console.log(`By symbol:`, stats.bySymbol);
+ * console.log(`By strategy:`, stats.byStrategy);
+ *
+ * // Generate markdown report
+ * const markdown = await Risk.getReport("BTCUSDT", "my-strategy");
+ * console.log(markdown); // Formatted table with all rejection events
+ *
+ * // Export report to file
+ * await Risk.dump("BTCUSDT", "my-strategy"); // Saves to ./dump/risk/BTCUSDT_my-strategy.md
+ * await Risk.dump("BTCUSDT", "my-strategy", "./custom/path"); // Custom directory
+ * ```
+ */
+class RiskUtils {
+    constructor() {
+        /**
+         * Retrieves statistical data from accumulated risk rejection events.
+         *
+         * Delegates to RiskMarkdownService.getData() which reads from ReportStorage.
+         * Returns aggregated metrics calculated from all rejection events.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy name (e.g., "my-strategy")
+         * @returns Promise resolving to RiskStatistics object with counts and event list
+         *
+         * @example
+         * ```typescript
+         * const stats = await Risk.getData("BTCUSDT", "my-strategy");
+         *
+         * console.log(`Total rejections: ${stats.totalRejections}`);
+         * console.log(`Rejections by symbol:`, stats.bySymbol);
+         * console.log(`Rejections by strategy:`, stats.byStrategy);
+         *
+         * // Iterate through all rejection events
+         * for (const event of stats.eventList) {
+         *   console.log(`REJECTED: ${event.symbol} - ${event.comment} (${event.activePositionCount} active)`);
+         * }
+         * ```
+         */
+        this.getData = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(RISK_METHOD_NAME_GET_DATA, { symbol, strategyName });
+            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_DATA);
+            {
+                const { riskName } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_DATA);
+            }
+            return await backtest$1.riskMarkdownService.getData(symbol, strategyName);
+        };
+        /**
+         * Generates markdown report with all risk rejection events for a symbol-strategy pair.
+         *
+         * Creates formatted table containing:
+         * - Symbol
+         * - Strategy
+         * - Position (LONG/SHORT)
+         * - Exchange
+         * - Price
+         * - Active Positions (at rejection time)
+         * - Reason (from validation note)
+         * - Timestamp (ISO 8601)
+         *
+         * Also includes summary statistics at the end (total rejections, by symbol, by strategy).
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy name (e.g., "my-strategy")
+         * @returns Promise resolving to markdown formatted report string
+         *
+         * @example
+         * ```typescript
+         * const markdown = await Risk.getReport("BTCUSDT", "my-strategy");
+         * console.log(markdown);
+         *
+         * // Output:
+         * // # Risk Rejection Report: BTCUSDT:my-strategy
+         * //
+         * // | Symbol | Strategy | Position | Exchange | Price | Active Positions | Reason | Timestamp |
+         * // | --- | --- | --- | --- | --- | --- | --- | --- |
+         * // | BTCUSDT | my-strategy | LONG | binance | 50000.00000000 USD | 3 | Max 3 positions allowed | 2024-01-15T10:30:00.000Z |
+         * //
+         * // **Total rejections:** 1
+         * //
+         * // ## Rejections by Symbol
+         * // - BTCUSDT: 1
+         * //
+         * // ## Rejections by Strategy
+         * // - my-strategy: 1
+         * ```
+         */
+        this.getReport = async (symbol, strategyName) => {
+            backtest$1.loggerService.info(RISK_METHOD_NAME_GET_REPORT, { symbol, strategyName });
+            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_GET_REPORT);
+            {
+                const { riskName } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT);
+            }
+            return await backtest$1.riskMarkdownService.getReport(symbol, strategyName);
+        };
+        /**
+         * Generates and saves markdown report to file.
+         *
+         * Creates directory if it doesn't exist.
+         * Filename format: {symbol}_{strategyName}.md (e.g., "BTCUSDT_my-strategy.md")
+         *
+         * Delegates to RiskMarkdownService.dump() which:
+         * 1. Generates markdown report via getReport()
+         * 2. Creates output directory (recursive mkdir)
+         * 3. Writes file with UTF-8 encoding
+         * 4. Logs success/failure to console
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param strategyName - Strategy name (e.g., "my-strategy")
+         * @param path - Output directory path (default: "./dump/risk")
+         * @returns Promise that resolves when file is written
+         *
+         * @example
+         * ```typescript
+         * // Save to default path: ./dump/risk/BTCUSDT_my-strategy.md
+         * await Risk.dump("BTCUSDT", "my-strategy");
+         *
+         * // Save to custom path: ./reports/risk/BTCUSDT_my-strategy.md
+         * await Risk.dump("BTCUSDT", "my-strategy", "./reports/risk");
+         *
+         * // After multiple symbols backtested, export all risk reports
+         * for (const symbol of ["BTCUSDT", "ETHUSDT", "BNBUSDT"]) {
+         *   await Risk.dump(symbol, "my-strategy", "./backtest-results");
+         * }
+         * ```
+         */
+        this.dump = async (symbol, strategyName, path) => {
+            backtest$1.loggerService.info(RISK_METHOD_NAME_DUMP, { symbol, strategyName, path });
+            backtest$1.strategyValidationService.validate(strategyName, RISK_METHOD_NAME_DUMP);
+            {
+                const { riskName } = backtest$1.strategySchemaService.get(strategyName);
+                riskName && backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP);
+            }
+            await backtest$1.riskMarkdownService.dump(symbol, strategyName, path);
+        };
+    }
+}
+/**
+ * Global singleton instance of RiskUtils.
+ * Provides static-like access to risk rejection reporting methods.
+ *
+ * @example
+ * ```typescript
+ * import { Risk } from "backtest-kit";
+ *
+ * // Usage same as RiskUtils methods
+ * const stats = await Risk.getData("BTCUSDT", "my-strategy");
+ * const report = await Risk.getReport("BTCUSDT", "my-strategy");
+ * await Risk.dump("BTCUSDT", "my-strategy");
+ * ```
+ */
+const Risk = new RiskUtils();
+
 exports.Backtest = Backtest;
 exports.Constant = Constant;
 exports.ExecutionContextService = ExecutionContextService;
@@ -16187,6 +16916,7 @@ exports.PersistRiskAdapter = PersistRiskAdapter;
 exports.PersistScheduleAdapter = PersistScheduleAdapter;
 exports.PersistSignalAdapter = PersistSignalAdapter;
 exports.PositionSize = PositionSize;
+exports.Risk = Risk;
 exports.Schedule = Schedule;
 exports.Walker = Walker;
 exports.addExchange = addExchange;
@@ -16229,6 +16959,8 @@ exports.listenPartialLossOnce = listenPartialLossOnce;
 exports.listenPartialProfit = listenPartialProfit;
 exports.listenPartialProfitOnce = listenPartialProfitOnce;
 exports.listenPerformance = listenPerformance;
+exports.listenRisk = listenRisk;
+exports.listenRiskOnce = listenRiskOnce;
 exports.listenSignal = listenSignal;
 exports.listenSignalBacktest = listenSignalBacktest;
 exports.listenSignalBacktestOnce = listenSignalBacktestOnce;