backtest-kit 1.5.16 → 1.5.18

package/build/index.cjs

@@ -111,6 +111,14 @@ const GLOBAL_CONFIG = {
      * Example: 3 candles = 12 points (use average), 5 candles = 20 points (use median)
      */
     CC_GET_CANDLES_MIN_CANDLES_FOR_MEDIAN: 5,
+    /**
+     * Controls visibility of signal notes in markdown report tables.
+     * When enabled, the "Note" column will be displayed in all markdown reports
+     * (backtest, live, schedule, risk, etc.)
+     *
+     * Default: false (notes are hidden to reduce table width and improve readability)
+     */
+    CC_REPORT_SHOW_SIGNAL_NOTE: false,
 };
 const DEFAULT_CONFIG = Object.freeze({ ...GLOBAL_CONFIG });
 
@@ -202,6 +210,7 @@ const markdownServices$1 = {
     heatMarkdownService: Symbol('heatMarkdownService'),
     partialMarkdownService: Symbol('partialMarkdownService'),
     outlineMarkdownService: Symbol('outlineMarkdownService'),
+    riskMarkdownService: Symbol('riskMarkdownService'),
 };
 const validationServices$1 = {
     exchangeValidationService: Symbol('exchangeValidationService'),
@@ -442,11 +451,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 +1735,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 +1755,7 @@ var emitters = /*#__PURE__*/Object.freeze({
     progressBacktestEmitter: progressBacktestEmitter,
     progressOptimizerEmitter: progressOptimizerEmitter,
     progressWalkerEmitter: progressWalkerEmitter,
+    riskSubject: riskSubject,
     signalBacktestEmitter: signalBacktestEmitter,
     signalEmitter: signalEmitter,
     signalLiveEmitter: signalLiveEmitter,
@@ -1825,6 +1842,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 +2131,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 +2828,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 +2837,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 +2850,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 +2859,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 +3814,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 +3890,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 +3971,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 +4043,7 @@ class RiskConnectionService {
             return new ClientRisk({
                 ...schema,
                 logger: this.loggerService,
+                onRejected: COMMIT_REJECTION_FN,
             });
         });
         /**
@@ -3994,6 +4051,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,46 +6040,54 @@ function isUnsafe$3(value) {
     }
     return false;
 }
-const columns$4 = [
+const columns$6 = [
     {
         key: "signalId",
         label: "Signal ID",
         format: (data) => data.signal.id,
+        isVisible: () => true,
     },
     {
         key: "symbol",
         label: "Symbol",
         format: (data) => data.signal.symbol,
+        isVisible: () => true,
     },
     {
         key: "position",
         label: "Position",
         format: (data) => data.signal.position.toUpperCase(),
+        isVisible: () => true,
     },
     {
         key: "note",
         label: "Note",
         format: (data) => toPlainString(data.signal.note ?? "N/A"),
+        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
     },
     {
         key: "openPrice",
         label: "Open Price",
         format: (data) => `${data.signal.priceOpen.toFixed(8)} USD`,
+        isVisible: () => true,
     },
     {
         key: "closePrice",
         label: "Close Price",
         format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
     },
     {
         key: "takeProfit",
         label: "Take Profit",
         format: (data) => `${data.signal.priceTakeProfit.toFixed(8)} USD`,
+        isVisible: () => true,
     },
     {
         key: "stopLoss",
         label: "Stop Loss",
         format: (data) => `${data.signal.priceStopLoss.toFixed(8)} USD`,
+        isVisible: () => true,
     },
     {
         key: "pnl",
@@ -6030,11 +6096,13 @@ const columns$4 = [
             const pnlPercentage = data.pnl.pnlPercentage;
             return `${pnlPercentage > 0 ? "+" : ""}${pnlPercentage.toFixed(2)}%`;
         },
+        isVisible: () => true,
     },
     {
         key: "closeReason",
         label: "Close Reason",
         format: (data) => data.closeReason,
+        isVisible: () => true,
     },
     {
         key: "duration",
@@ -6044,23 +6112,28 @@ const columns$4 = [
             const durationMin = Math.round(durationMs / 60000);
             return `${durationMin}`;
         },
+        isVisible: () => true,
     },
     {
         key: "openTimestamp",
         label: "Open Time",
         format: (data) => new Date(data.signal.pendingAt).toISOString(),
+        isVisible: () => true,
     },
     {
         key: "closeTimestamp",
         label: "Close Time",
         format: (data) => new Date(data.closeTimestamp).toISOString(),
+        isVisible: () => true,
     },
 ];
+/** 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 +6144,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 +6231,10 @@ 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 visibleColumns = columns$6.filter((col) => col.isVisible());
+        const header = visibleColumns.map((col) => col.label);
+        const separator = visibleColumns.map(() => "---");
+        const rows = this._signalList.map((closedSignal) => visibleColumns.map((col) => col.format(closedSignal)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map(row => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -6232,7 +6310,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,46 +6481,54 @@ function isUnsafe$2(value) {
     }
     return false;
 }
-const columns$3 = [
+const columns$5 = [
     {
         key: "timestamp",
         label: "Timestamp",
         format: (data) => new Date(data.timestamp).toISOString(),
+        isVisible: () => true,
     },
     {
         key: "action",
         label: "Action",
         format: (data) => data.action.toUpperCase(),
+        isVisible: () => true,
     },
     {
         key: "symbol",
         label: "Symbol",
         format: (data) => data.symbol ?? "N/A",
+        isVisible: () => true,
     },
     {
         key: "signalId",
         label: "Signal ID",
         format: (data) => data.signalId ?? "N/A",
+        isVisible: () => true,
     },
     {
         key: "position",
         label: "Position",
         format: (data) => data.position?.toUpperCase() ?? "N/A",
+        isVisible: () => true,
     },
     {
         key: "note",
         label: "Note",
         format: (data) => toPlainString(data.note ?? "N/A"),
+        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
     },
     {
         key: "currentPrice",
         label: "Current Price",
         format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
     },
     {
         key: "openPrice",
         label: "Open Price",
         format: (data) => data.openPrice !== undefined ? `${data.openPrice.toFixed(8)} USD` : "N/A",
+        isVisible: () => true,
     },
     {
         key: "takeProfit",
@@ -6450,21 +6536,25 @@ const columns$3 = [
         format: (data) => data.takeProfit !== undefined
             ? `${data.takeProfit.toFixed(8)} USD`
             : "N/A",
+        isVisible: () => true,
     },
     {
         key: "stopLoss",
         label: "Stop Loss",
         format: (data) => data.stopLoss !== undefined ? `${data.stopLoss.toFixed(8)} USD` : "N/A",
+        isVisible: () => true,
     },
     {
         key: "percentTp",
         label: "% to TP",
         format: (data) => data.percentTp !== undefined ? `${data.percentTp.toFixed(2)}%` : "N/A",
+        isVisible: () => true,
     },
     {
         key: "percentSl",
         label: "% to SL",
         format: (data) => data.percentSl !== undefined ? `${data.percentSl.toFixed(2)}%` : "N/A",
+        isVisible: () => true,
     },
     {
         key: "pnl",
@@ -6474,25 +6564,28 @@ const columns$3 = [
                 return "N/A";
             return `${data.pnl > 0 ? "+" : ""}${data.pnl.toFixed(2)}%`;
         },
+        isVisible: () => true,
     },
     {
         key: "closeReason",
         label: "Close Reason",
         format: (data) => data.closeReason ?? "N/A",
+        isVisible: () => true,
     },
     {
         key: "duration",
         label: "Duration (min)",
         format: (data) => data.duration !== undefined ? `${data.duration}` : "N/A",
+        isVisible: () => true,
     },
 ];
 /** Maximum number of events to store in live trading reports */
-const MAX_EVENTS$4 = 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 +6612,9 @@ let ReportStorage$3 = class ReportStorage {
             return;
         }
         {
-            this._eventList.push(newEvent);
-            if (this._eventList.length > MAX_EVENTS$4) {
-                this._eventList.shift();
+            this._eventList.unshift(newEvent);
+            if (this._eventList.length > MAX_EVENTS$5) {
+                this._eventList.pop();
             }
         }
     }
@@ -6531,7 +6624,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 +6637,13 @@ let ReportStorage$3 = class ReportStorage {
             stopLoss: data.signal.priceStopLoss,
         });
         // Trim queue if exceeded MAX_EVENTS
-        if (this._eventList.length > MAX_EVENTS$4) {
-            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 +6662,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$4) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$5) {
+            this._eventList.pop();
         }
     }
     /**
@@ -6597,10 +6699,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$4) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$5) {
+            this._eventList.pop();
         }
     }
     /**
@@ -6699,9 +6801,10 @@ 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 visibleColumns = columns$5.filter((col) => col.isVisible());
+        const header = visibleColumns.map((col) => col.label);
+        const separator = visibleColumns.map(() => "---");
+        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map(row => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -6780,7 +6883,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,70 +7046,81 @@ class LiveMarkdownService {
     }
 }
 
-const columns$2 = [
+const columns$4 = [
     {
         key: "timestamp",
         label: "Timestamp",
         format: (data) => new Date(data.timestamp).toISOString(),
+        isVisible: () => true,
     },
     {
         key: "action",
         label: "Action",
         format: (data) => data.action.toUpperCase(),
+        isVisible: () => true,
     },
     {
         key: "symbol",
         label: "Symbol",
         format: (data) => data.symbol,
+        isVisible: () => true,
     },
     {
         key: "signalId",
         label: "Signal ID",
         format: (data) => data.signalId,
+        isVisible: () => true,
     },
     {
         key: "position",
         label: "Position",
         format: (data) => data.position.toUpperCase(),
+        isVisible: () => true,
     },
     {
         key: "note",
         label: "Note",
         format: (data) => toPlainString(data.note ?? "N/A"),
+        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
     },
     {
         key: "currentPrice",
         label: "Current Price",
         format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
     },
     {
         key: "priceOpen",
         label: "Entry Price",
         format: (data) => `${data.priceOpen.toFixed(8)} USD`,
+        isVisible: () => true,
     },
     {
         key: "takeProfit",
         label: "Take Profit",
         format: (data) => `${data.takeProfit.toFixed(8)} USD`,
+        isVisible: () => true,
     },
     {
         key: "stopLoss",
         label: "Stop Loss",
         format: (data) => `${data.stopLoss.toFixed(8)} USD`,
+        isVisible: () => true,
     },
     {
         key: "duration",
         label: "Wait Time (min)",
         format: (data) => data.duration !== undefined ? `${data.duration}` : "N/A",
+        isVisible: () => true,
     },
 ];
 /** Maximum number of events to store in schedule reports */
-const MAX_EVENTS$3 = 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 +7131,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 +7144,8 @@ let ReportStorage$2 = 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$4) {
+            this._eventList.pop();
         }
     }
     /**
@@ -7055,10 +7169,10 @@ let ReportStorage$2 = class ReportStorage {
             stopLoss: data.signal.priceStopLoss,
             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$4) {
+            this._eventList.pop();
         }
     }
     /**
@@ -7083,10 +7197,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$3) {
-            this._eventList.shift();
+        if (this._eventList.length > MAX_EVENTS$4) {
+            this._eventList.pop();
         }
     }
     /**
@@ -7155,9 +7269,10 @@ 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 visibleColumns = columns$4.filter((col) => col.isVisible());
+        const header = visibleColumns.map((col) => col.label);
+        const separator = visibleColumns.map(() => "---");
+        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -7225,7 +7340,7 @@ 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/opened/cancelled events.
          * Should be called from signalEmitter subscription.
@@ -7391,8 +7506,88 @@ function percentile(sortedArray, p) {
     const index = Math.ceil((sortedArray.length * p) / 100) - 1;
     return sortedArray[Math.max(0, index)];
 }
+const columns$3 = [
+    {
+        key: "metricType",
+        label: "Metric Type",
+        format: (data) => data.metricType,
+        isVisible: () => true,
+    },
+    {
+        key: "count",
+        label: "Count",
+        format: (data) => data.count.toString(),
+        isVisible: () => true,
+    },
+    {
+        key: "totalDuration",
+        label: "Total (ms)",
+        format: (data) => data.totalDuration.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "avgDuration",
+        label: "Avg (ms)",
+        format: (data) => data.avgDuration.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "minDuration",
+        label: "Min (ms)",
+        format: (data) => data.minDuration.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "maxDuration",
+        label: "Max (ms)",
+        format: (data) => data.maxDuration.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "stdDev",
+        label: "Std Dev (ms)",
+        format: (data) => data.stdDev.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "median",
+        label: "Median (ms)",
+        format: (data) => data.median.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "p95",
+        label: "P95 (ms)",
+        format: (data) => data.p95.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "p99",
+        label: "P99 (ms)",
+        format: (data) => data.p99.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "avgWaitTime",
+        label: "Avg Wait (ms)",
+        format: (data) => data.avgWaitTime.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "minWaitTime",
+        label: "Min Wait (ms)",
+        format: (data) => data.minWaitTime.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "maxWaitTime",
+        label: "Max Wait (ms)",
+        format: (data) => data.maxWaitTime.toFixed(2),
+        isVisible: () => true,
+    },
+];
 /** Maximum number of performance events to store per strategy */
-const MAX_EVENTS$2 = 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.
@@ -7408,10 +7603,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$2) {
-            this._events.shift();
+        if (this._events.length > MAX_EVENTS$3) {
+            this._events.pop();
         }
     }
     /**
@@ -7506,40 +7701,13 @@ class PerformanceStorage {
         }
         // Sort metrics by total duration (descending) to show bottlenecks first
         const sortedMetrics = Object.values(stats.metricStats).sort((a, b) => b.totalDuration - a.totalDuration);
-        // Generate summary table
-        const summaryHeader = [
-            "Metric Type",
-            "Count",
-            "Total (ms)",
-            "Avg (ms)",
-            "Min (ms)",
-            "Max (ms)",
-            "Std Dev (ms)",
-            "Median (ms)",
-            "P95 (ms)",
-            "P99 (ms)",
-            "Avg Wait (ms)",
-            "Min Wait (ms)",
-            "Max Wait (ms)",
-        ];
-        const summarySeparator = summaryHeader.map(() => "---");
-        const summaryRows = sortedMetrics.map((metric) => [
-            metric.metricType,
-            metric.count.toString(),
-            metric.totalDuration.toFixed(2),
-            metric.avgDuration.toFixed(2),
-            metric.minDuration.toFixed(2),
-            metric.maxDuration.toFixed(2),
-            metric.stdDev.toFixed(2),
-            metric.median.toFixed(2),
-            metric.p95.toFixed(2),
-            metric.p99.toFixed(2),
-            metric.avgWaitTime.toFixed(2),
-            metric.minWaitTime.toFixed(2),
-            metric.maxWaitTime.toFixed(2),
-        ]);
-        const summaryTableData = [summaryHeader, summarySeparator, ...summaryRows];
-        const summaryTable = summaryTableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
+        // Generate summary table using Column interface
+        const visibleColumns = columns$3.filter((col) => col.isVisible());
+        const header = visibleColumns.map((col) => col.label);
+        const separator = visibleColumns.map(() => "---");
+        const rows = sortedMetrics.map((metric) => visibleColumns.map((col) => col.format(metric)));
+        const tableData = [header, separator, ...rows];
+        const summaryTable = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         // Calculate percentage of total time for each metric
         const percentages = sortedMetrics.map((metric) => {
             const pct = (metric.totalDuration / stats.totalDuration) * 100;
@@ -7774,21 +7942,25 @@ function createStrategyColumns(metric) {
             key: "rank",
             label: "Rank",
             format: (data, index) => `${index + 1}`,
+            isVisible: () => true,
         },
         {
             key: "strategy",
             label: "Strategy",
             format: (data) => data.strategyName,
+            isVisible: () => true,
         },
         {
             key: "metric",
             label: metric,
             format: (data) => formatMetric(data.metricValue),
+            isVisible: () => true,
         },
         {
             key: "totalSignals",
             label: "Total Signals",
             format: (data) => `${data.stats.totalSignals}`,
+            isVisible: () => true,
         },
         {
             key: "winRate",
@@ -7796,6 +7968,7 @@ function createStrategyColumns(metric) {
             format: (data) => data.stats.winRate !== null
                 ? `${data.stats.winRate.toFixed(2)}%`
                 : "N/A",
+            isVisible: () => true,
         },
         {
             key: "avgPnl",
@@ -7803,6 +7976,7 @@ function createStrategyColumns(metric) {
             format: (data) => data.stats.avgPnl !== null
                 ? `${data.stats.avgPnl > 0 ? "+" : ""}${data.stats.avgPnl.toFixed(2)}%`
                 : "N/A",
+            isVisible: () => true,
         },
         {
             key: "totalPnl",
@@ -7810,6 +7984,7 @@ function createStrategyColumns(metric) {
             format: (data) => data.stats.totalPnl !== null
                 ? `${data.stats.totalPnl > 0 ? "+" : ""}${data.stats.totalPnl.toFixed(2)}%`
                 : "N/A",
+            isVisible: () => true,
         },
         {
             key: "sharpeRatio",
@@ -7817,6 +7992,7 @@ function createStrategyColumns(metric) {
             format: (data) => data.stats.sharpeRatio !== null
                 ? `${data.stats.sharpeRatio.toFixed(3)}`
                 : "N/A",
+            isVisible: () => true,
         },
         {
             key: "stdDev",
@@ -7824,6 +8000,7 @@ function createStrategyColumns(metric) {
             format: (data) => data.stats.stdDev !== null
                 ? `${data.stats.stdDev.toFixed(3)}%`
                 : "N/A",
+            isVisible: () => true,
         },
     ];
 }
@@ -7836,48 +8013,56 @@ const pnlColumns = [
         key: "strategy",
         label: "Strategy",
         format: (data) => data.strategyName,
+        isVisible: () => true,
     },
     {
         key: "signalId",
         label: "Signal ID",
         format: (data) => data.signalId,
+        isVisible: () => true,
     },
     {
         key: "symbol",
         label: "Symbol",
         format: (data) => data.symbol,
+        isVisible: () => true,
     },
     {
         key: "position",
         label: "Position",
         format: (data) => data.position.toUpperCase(),
+        isVisible: () => true,
     },
     {
         key: "pnl",
         label: "PNL (net)",
         format: (data) => `${data.pnl > 0 ? "+" : ""}${data.pnl.toFixed(2)}%`,
+        isVisible: () => true,
     },
     {
         key: "closeReason",
         label: "Close Reason",
         format: (data) => data.closeReason,
+        isVisible: () => true,
     },
     {
         key: "openTime",
         label: "Open Time",
         format: (data) => new Date(data.openTime).toISOString(),
+        isVisible: () => true,
     },
     {
         key: "closeTime",
         label: "Close Time",
         format: (data) => new Date(data.closeTime).toISOString(),
+        isVisible: () => true,
     },
 ];
 /**
  * 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) */
@@ -7895,17 +8080,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,
@@ -7959,11 +8140,12 @@ let ReportStorage$1 = class ReportStorage {
         const topStrategies = sortedResults.slice(0, topN);
         // Get columns configuration
         const columns = createStrategyColumns(metric);
+        const visibleColumns = columns.filter((col) => col.isVisible());
         // Build table header
-        const header = columns.map((col) => col.label);
-        const separator = columns.map(() => "---");
+        const header = visibleColumns.map((col) => col.label);
+        const separator = visibleColumns.map(() => "---");
         // Build table rows
-        const rows = topStrategies.map((result, index) => columns.map((col) => col.format(result, index)));
+        const rows = topStrategies.map((result, index) => visibleColumns.map((col) => col.format(result, index)));
         const tableData = [header, separator, ...rows];
         return tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
     }
@@ -7997,10 +8179,11 @@ let ReportStorage$1 = class ReportStorage {
             return "No closed signals available.";
         }
         // Build table header
-        const header = pnlColumns.map((col) => col.label);
-        const separator = pnlColumns.map(() => "---");
+        const visibleColumns = pnlColumns.filter((col) => col.isVisible());
+        const header = visibleColumns.map((col) => col.label);
+        const separator = visibleColumns.map(() => "---");
         // Build table rows
-        const rows = allSignals.map((signal) => pnlColumns.map((col) => col.format(signal)));
+        const rows = allSignals.map((signal) => visibleColumns.map((col) => col.format(signal)));
         const tableData = [header, separator, ...rows];
         return tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
     }
@@ -8089,7 +8272,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.
@@ -8260,70 +8443,82 @@ function isUnsafe(value) {
     }
     return false;
 }
-const columns$1 = [
+const columns$2 = [
     {
         key: "symbol",
         label: "Symbol",
         format: (data) => data.symbol,
+        isVisible: () => true,
     },
     {
         key: "totalPnl",
         label: "Total PNL",
         format: (data) => data.totalPnl !== null ? functoolsKit.str(data.totalPnl, "%+.2f%%") : "N/A",
+        isVisible: () => true,
     },
     {
         key: "sharpeRatio",
         label: "Sharpe",
         format: (data) => data.sharpeRatio !== null ? functoolsKit.str(data.sharpeRatio, "%.2f") : "N/A",
+        isVisible: () => true,
     },
     {
         key: "profitFactor",
         label: "PF",
         format: (data) => data.profitFactor !== null ? functoolsKit.str(data.profitFactor, "%.2f") : "N/A",
+        isVisible: () => true,
     },
     {
         key: "expectancy",
         label: "Expect",
         format: (data) => data.expectancy !== null ? functoolsKit.str(data.expectancy, "%+.2f%%") : "N/A",
+        isVisible: () => true,
     },
     {
         key: "winRate",
         label: "WR",
         format: (data) => data.winRate !== null ? functoolsKit.str(data.winRate, "%.1f%%") : "N/A",
+        isVisible: () => true,
     },
     {
         key: "avgWin",
         label: "Avg Win",
         format: (data) => data.avgWin !== null ? functoolsKit.str(data.avgWin, "%+.2f%%") : "N/A",
+        isVisible: () => true,
     },
     {
         key: "avgLoss",
         label: "Avg Loss",
         format: (data) => data.avgLoss !== null ? functoolsKit.str(data.avgLoss, "%+.2f%%") : "N/A",
+        isVisible: () => true,
     },
     {
         key: "maxDrawdown",
         label: "Max DD",
         format: (data) => data.maxDrawdown !== null ? functoolsKit.str(-data.maxDrawdown, "%.2f%%") : "N/A",
+        isVisible: () => true,
     },
     {
         key: "maxWinStreak",
         label: "W Streak",
         format: (data) => data.maxWinStreak.toString(),
+        isVisible: () => true,
     },
     {
         key: "maxLossStreak",
         label: "L Streak",
         format: (data) => data.maxLossStreak.toString(),
+        isVisible: () => true,
     },
     {
         key: "totalTrades",
         label: "Trades",
         format: (data) => data.totalTrades.toString(),
+        isVisible: () => true,
     },
 ];
 /** Maximum number of signals to store per symbol in heatmap reports */
-const MAX_EVENTS$1 = 250;
+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.
@@ -8344,10 +8539,10 @@ class HeatmapStorage {
             this.symbolData.set(symbol, []);
         }
         const signals = this.symbolData.get(symbol);
-        signals.push(data);
+        signals.unshift(data);
         // Trim queue if exceeded MAX_EVENTS per symbol
-        if (signals.length > MAX_EVENTS$1) {
-            signals.shift();
+        if (signals.length > MAX_EVENTS$2) {
+            signals.pop();
         }
     }
     /**
@@ -8567,9 +8762,10 @@ 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 visibleColumns = columns$2.filter((col) => col.isVisible());
+        const header = visibleColumns.map((col) => col.label);
+        const separator = visibleColumns.map(() => "---");
+        const rows = data.symbols.map((row) => visibleColumns.map((col) => col.format(row)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -10607,7 +10803,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) {
@@ -10654,7 +10850,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) {
@@ -10925,6 +11121,7 @@ class ClientPartial {
             symbol,
             data,
             priceClose,
+            backtest,
         });
         if (this._states === NEED_FETCH) {
             throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
@@ -10941,14 +11138,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,
@@ -10962,14 +11163,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,
@@ -11115,60 +11320,69 @@ class PartialConnectionService {
     }
 }
 
-const columns = [
+const columns$1 = [
     {
         key: "action",
         label: "Action",
         format: (data) => data.action.toUpperCase(),
+        isVisible: () => true,
     },
     {
         key: "symbol",
         label: "Symbol",
         format: (data) => data.symbol,
+        isVisible: () => true,
     },
     {
         key: "strategyName",
         label: "Strategy",
         format: (data) => data.strategyName,
+        isVisible: () => true,
     },
     {
         key: "signalId",
         label: "Signal ID",
         format: (data) => data.signalId,
+        isVisible: () => true,
     },
     {
         key: "position",
         label: "Position",
         format: (data) => data.position.toUpperCase(),
+        isVisible: () => true,
     },
     {
         key: "level",
         label: "Level %",
         format: (data) => data.action === "profit" ? `+${data.level}%` : `-${data.level}%`,
+        isVisible: () => true,
     },
     {
         key: "currentPrice",
         label: "Current Price",
         format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
     },
     {
         key: "timestamp",
         label: "Timestamp",
         format: (data) => new Date(data.timestamp).toISOString(),
+        isVisible: () => true,
     },
     {
         key: "mode",
         label: "Mode",
         format: (data) => (data.backtest ? "Backtest" : "Live"),
+        isVisible: () => true,
     },
 ];
 /** 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 = [];
@@ -11182,7 +11396,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,
@@ -11194,8 +11408,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();
         }
     }
     /**
@@ -11207,7 +11421,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,
@@ -11219,8 +11433,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();
         }
     }
     /**
@@ -11262,9 +11476,10 @@ 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 visibleColumns = columns$1.filter((col) => col.isVisible());
+        const header = visibleColumns.map((col) => col.label);
+        const separator = visibleColumns.map(() => "---");
+        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -11298,7 +11513,7 @@ class ReportStorage {
             console.error(`Failed to save markdown report:`, error);
         }
     }
-}
+};
 /**
  * Service for generating and saving partial profit/loss markdown reports.
  *
@@ -11328,7 +11543,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.
@@ -11638,7 +11853,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.
@@ -11900,6 +12115,372 @@ class ConfigValidationService {
     }
 }
 
+const columns = [
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "strategyName",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+        isVisible: () => true,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.pendingSignal.id || "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.pendingSignal.position.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "note",
+        label: "Note",
+        format: (data) => toPlainString(data.pendingSignal.note ?? "N/A"),
+        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
+    },
+    {
+        key: "exchangeName",
+        label: "Exchange",
+        format: (data) => data.exchangeName,
+        isVisible: () => true,
+    },
+    {
+        key: "openPrice",
+        label: "Open Price",
+        format: (data) => data.pendingSignal.priceOpen !== undefined
+            ? `${data.pendingSignal.priceOpen.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "takeProfit",
+        label: "Take Profit",
+        format: (data) => data.pendingSignal.priceTakeProfit !== undefined
+            ? `${data.pendingSignal.priceTakeProfit.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "stopLoss",
+        label: "Stop Loss",
+        format: (data) => data.pendingSignal.priceStopLoss !== undefined
+            ? `${data.pendingSignal.priceStopLoss.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "currentPrice",
+        label: "Current Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "activePositionCount",
+        label: "Active Positions",
+        format: (data) => data.activePositionCount.toString(),
+        isVisible: () => true,
+    },
+    {
+        key: "comment",
+        label: "Reason",
+        format: (data) => data.comment,
+        isVisible: () => true,
+    },
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+        isVisible: () => true,
+    },
+];
+/** 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 visibleColumns = columns.filter((col) => col.isVisible());
+        const header = visibleColumns.map((col) => col.label);
+        const separator = visibleColumns.map(() => "---");
+        const rows = this._eventList.map((event) => visibleColumns.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);
+        }
+    }
+}
+/**
+ * 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());
 }
@@ -11960,6 +12541,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());
@@ -12035,6 +12617,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),
@@ -12809,6 +13392,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.
  *
@@ -13607,6 +14192,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";
@@ -16231,6 +16885,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;
@@ -16246,6 +17080,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;
@@ -16288,6 +17123,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;