backtest-kit 1.5.25 → 1.5.26

package/build/index.cjs

@@ -122,6 +122,1081 @@ const GLOBAL_CONFIG = {
 };
 const DEFAULT_CONFIG = Object.freeze({ ...GLOBAL_CONFIG });
 
+/**
+ * Converts markdown content to plain text with minimal formatting
+ * @param content - Markdown string to convert
+ * @returns Plain text representation
+ */
+const toPlainString = (content) => {
+    if (!content) {
+        return "";
+    }
+    let text = content;
+    // Remove code blocks
+    text = text.replace(/```[\s\S]*?```/g, "");
+    text = text.replace(/`([^`]+)`/g, "$1");
+    // Remove images
+    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1");
+    // Convert links to text only (keep link text, remove URL)
+    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    // Remove headers (convert to plain text)
+    text = text.replace(/^#{1,6}\s+(.+)$/gm, "$1");
+    // Remove bold and italic markers
+    text = text.replace(/\*\*\*(.+?)\*\*\*/g, "$1");
+    text = text.replace(/\*\*(.+?)\*\*/g, "$1");
+    text = text.replace(/\*(.+?)\*/g, "$1");
+    text = text.replace(/___(.+?)___/g, "$1");
+    text = text.replace(/__(.+?)__/g, "$1");
+    text = text.replace(/_(.+?)_/g, "$1");
+    // Remove strikethrough
+    text = text.replace(/~~(.+?)~~/g, "$1");
+    // Convert lists to plain text with bullets
+    text = text.replace(/^\s*[-*+]\s+/gm, "• ");
+    text = text.replace(/^\s*\d+\.\s+/gm, "• ");
+    // Remove blockquotes
+    text = text.replace(/^\s*>\s+/gm, "");
+    // Remove horizontal rules
+    text = text.replace(/^(\*{3,}|-{3,}|_{3,})$/gm, "");
+    // Remove HTML tags
+    text = text.replace(/<[^>]+>/g, "");
+    // Remove excessive whitespace and normalize line breaks
+    text = text.replace(/\n[\s\n]*\n/g, "\n");
+    text = text.replace(/[ \t]+/g, " ");
+    // Remove all newline characters
+    text = text.replace(/\n/g, " ");
+    // Remove excessive spaces after newline removal
+    text = text.replace(/\s+/g, " ");
+    return text.trim();
+};
+
+/**
+ * Column configuration for backtest markdown reports.
+ *
+ * Defines the table structure for displaying closed trading signals in backtest reports.
+ * Each column specifies how to format and display specific signal data fields.
+ *
+ * Used by {@link BacktestMarkdownService} to generate markdown tables showing:
+ * - Signal identification (ID, symbol, position)
+ * - Price levels (open, close, take profit, stop loss)
+ * - Performance metrics (PNL percentage, close reason)
+ * - Timing information (duration, timestamps)
+ *
+ * @remarks
+ * Columns can be conditionally visible based on {@link GLOBAL_CONFIG} settings.
+ * For example, the "note" column visibility is controlled by `CC_REPORT_SHOW_SIGNAL_NOTE`.
+ *
+ * @example
+ * ```typescript
+ * import { backtest_columns } from "./assets/backtest.columns";
+ *
+ * // Use with BacktestMarkdownService
+ * const service = new BacktestMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", backtest_columns);
+ *
+ * // Or customize columns
+ * const customColumns = backtest_columns.filter(col => col.key !== "note");
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link BacktestMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link IStrategyTickResultClosed} for data structure
+ */
+const backtest_columns = [
+    {
+        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",
+        label: "PNL (net)",
+        format: (data) => {
+            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",
+        label: "Duration (min)",
+        format: (data) => {
+            const durationMs = data.closeTimestamp - data.signal.pendingAt;
+            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,
+    },
+];
+
+/**
+ * Column configuration for portfolio heatmap markdown reports.
+ *
+ * Defines the table structure for displaying aggregated per-symbol statistics in portfolio heatmap reports.
+ * Each column specifies how to format and display portfolio performance metrics across different trading symbols.
+ *
+ * Used by {@link HeatMarkdownService} to generate markdown tables showing:
+ * - Symbol identification
+ * - Performance metrics (Total PNL, Sharpe Ratio, Profit Factor, Expectancy)
+ * - Risk metrics (Win Rate, Average Win/Loss, Max Drawdown)
+ * - Trading activity (Total Trades, Win/Loss Streaks)
+ *
+ * @remarks
+ * This configuration is used to create portfolio-wide views that aggregate statistics per symbol.
+ * The heatmap service automatically sorts symbols by Sharpe Ratio (best performers first).
+ *
+ * @example
+ * ```typescript
+ * import { heat_columns } from "./assets/heat.columns";
+ *
+ * // Use with HeatMarkdownService
+ * const service = new HeatMarkdownService();
+ * await service.getReport("my-strategy", heat_columns);
+ *
+ * // Or customize to show only key metrics
+ * const customColumns = heat_columns.filter(col =>
+ *   ["symbol", "totalPnl", "sharpeRatio", "totalTrades"].includes(col.key)
+ * );
+ * await service.getReport("my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link HeatMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link IHeatmapRow} for data structure
+ */
+const heat_columns = [
+    {
+        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,
+    },
+];
+
+/**
+ * Column configuration for live trading markdown reports.
+ *
+ * Defines the table structure for displaying real-time trading events in live trading reports.
+ * Each column specifies how to format and display live trading event data fields.
+ *
+ * Used by {@link LiveMarkdownService} to generate markdown tables showing:
+ * - Event information (timestamp, action type)
+ * - Signal identification (symbol, signal ID, position)
+ * - Price data (current price, open price, take profit, stop loss)
+ * - Performance metrics (PNL percentage, close reason, duration)
+ * - Position tracking (percentage to TP/SL)
+ *
+ * @remarks
+ * This configuration tracks all event types: idle, opened, active, and closed signals.
+ * The "note" column visibility is controlled by {@link GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE}.
+ *
+ * @example
+ * ```typescript
+ * import { live_columns } from "./assets/live.columns";
+ *
+ * // Use with LiveMarkdownService
+ * const service = new LiveMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", live_columns);
+ *
+ * // Or customize for minimal display
+ * const customColumns = live_columns.filter(col =>
+ *   ["timestamp", "action", "symbol", "pnl"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link LiveMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link TickEvent} for data structure
+ */
+const live_columns = [
+    {
+        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",
+        label: "Take Profit",
+        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",
+        label: "PNL (net)",
+        format: (data) => {
+            if (data.pnl === undefined)
+                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,
+    },
+];
+
+/**
+ * Column configuration for partial profit/loss markdown reports.
+ *
+ * Defines the table structure for displaying partial position exit events in trading reports.
+ * Each column specifies how to format and display partial profit and loss level events.
+ *
+ * Used by {@link PartialMarkdownService} to generate markdown tables showing:
+ * - Event information (action type: profit or loss)
+ * - Signal identification (symbol, strategy name, signal ID, position)
+ * - Exit level information (percentage level reached)
+ * - Price data (current price at partial exit)
+ * - Timing information (timestamp, mode: backtest or live)
+ *
+ * @remarks
+ * This configuration tracks partial position exits at predefined profit/loss levels.
+ * The "note" column visibility is controlled by {@link GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE}.
+ * Useful for analyzing risk management strategies and partial exit performance.
+ *
+ * @example
+ * ```typescript
+ * import { partial_columns } from "./assets/partial.columns";
+ *
+ * // Use with PartialMarkdownService
+ * const service = new PartialMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", partial_columns);
+ *
+ * // Or customize to show only key fields
+ * const customColumns = partial_columns.filter(col =>
+ *   ["action", "symbol", "level", "timestamp"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link PartialMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link PartialEvent} for data structure
+ */
+const partial_columns = [
+    {
+        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,
+    },
+];
+
+/**
+ * Column configuration for performance metrics markdown reports.
+ *
+ * Defines the table structure for displaying performance statistics and timing metrics in performance reports.
+ * Each column specifies how to format and display aggregated performance data for different metric types.
+ *
+ * Used by {@link PerformanceMarkdownService} to generate markdown tables showing:
+ * - Metric identification (metric type)
+ * - Execution statistics (count, total duration, average, min, max)
+ * - Distribution metrics (standard deviation, median, percentiles)
+ * - Wait time statistics (average, min, max wait times between events)
+ *
+ * @remarks
+ * This configuration helps identify performance bottlenecks in strategy execution.
+ * The service automatically sorts metrics by total duration to highlight the slowest operations.
+ * All durations are measured in milliseconds.
+ *
+ * @example
+ * ```typescript
+ * import { performance_columns } from "./assets/performance.columns";
+ *
+ * // Use with PerformanceMarkdownService
+ * const service = new PerformanceMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", performance_columns);
+ *
+ * // Or customize for bottleneck analysis
+ * const customColumns = performance_columns.filter(col =>
+ *   ["metricType", "count", "avgDuration", "maxDuration", "p95"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link PerformanceMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link MetricStats} for data structure
+ */
+const performance_columns = [
+    {
+        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,
+    },
+];
+
+/**
+ * Column configuration for risk management markdown reports.
+ *
+ * Defines the table structure for displaying risk rejection events in risk management reports.
+ * Each column specifies how to format and display signals that were rejected due to risk limits.
+ *
+ * Used by {@link RiskMarkdownService} to generate markdown tables showing:
+ * - Signal identification (symbol, strategy name, signal ID, position)
+ * - Exchange information (exchange name, active position count)
+ * - Price data (open price, take profit, stop loss, current price)
+ * - Rejection details (rejection reason/comment, timestamp)
+ *
+ * @remarks
+ * This configuration helps analyze when and why the risk management system rejected signals.
+ * The "note" column visibility is controlled by {@link GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE}.
+ * Useful for tuning risk parameters and understanding risk control effectiveness.
+ *
+ * @example
+ * ```typescript
+ * import { risk_columns } from "./assets/risk.columns";
+ *
+ * // Use with RiskMarkdownService
+ * const service = new RiskMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", risk_columns);
+ *
+ * // Or customize to focus on rejection reasons
+ * const customColumns = risk_columns.filter(col =>
+ *   ["symbol", "strategyName", "comment", "activePositionCount", "timestamp"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link RiskMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link RiskEvent} for data structure
+ */
+const risk_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,
+    },
+];
+
+/**
+ * Column configuration for scheduled signals markdown reports.
+ *
+ * Defines the table structure for displaying scheduled, opened, and cancelled signal events.
+ * Each column specifies how to format and display signal scheduling and activation data.
+ *
+ * Used by {@link ScheduleMarkdownService} to generate markdown tables showing:
+ * - Event information (timestamp, action: scheduled/opened/cancelled)
+ * - Signal identification (symbol, signal ID, position)
+ * - Price data (current price, entry price, take profit, stop loss)
+ * - Timing information (wait time in minutes before activation or cancellation)
+ *
+ * @remarks
+ * This configuration tracks the lifecycle of scheduled signals from creation to activation or cancellation.
+ * The "note" column visibility is controlled by {@link GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE}.
+ * Helps analyze signal scheduling effectiveness and cancellation patterns.
+ *
+ * @example
+ * ```typescript
+ * import { schedule_columns } from "./assets/schedule.columns";
+ *
+ * // Use with ScheduleMarkdownService
+ * const service = new ScheduleMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", schedule_columns);
+ *
+ * // Or customize for timing analysis
+ * const customColumns = schedule_columns.filter(col =>
+ *   ["timestamp", "action", "symbol", "duration"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link ScheduleMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link ScheduledEvent} for data structure
+ */
+const schedule_columns = [
+    {
+        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,
+    },
+];
+
+/**
+ * Column configuration for walker strategy comparison table in markdown reports.
+ *
+ * Defines the table structure for displaying strategy comparison results in walker backtest reports.
+ * Each column specifies how to format and display aggregated strategy performance metrics.
+ *
+ * Used by {@link WalkerMarkdownService} to generate markdown tables showing:
+ * - Strategy ranking and identification
+ * - Optimization metric value (generic "Metric" column)
+ * - Performance statistics (Total Signals, Win Rate, Average PNL, Total PNL)
+ * - Risk metrics (Sharpe Ratio, Standard Deviation)
+ *
+ * @remarks
+ * This configuration is used in walker reports to compare multiple strategy configurations.
+ * The "Metric" column displays the value of the metric being optimized (Sharpe, PNL, etc.).
+ * Strategies are automatically sorted by metric value (best performers first).
+ *
+ * @example
+ * ```typescript
+ * import { walker_strategy_columns } from "./assets/walker.columns";
+ *
+ * // Use with WalkerMarkdownService for strategy comparison
+ * const service = new WalkerMarkdownService();
+ * await service.getReport(
+ *   "my-walker",
+ *   "BTCUSDT",
+ *   "sharpeRatio",
+ *   { exchangeName: "binance", frameName: "1d" },
+ *   walker_strategy_columns
+ * );
+ * ```
+ *
+ * @see {@link WalkerMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link IStrategyResult} for data structure
+ */
+const walker_strategy_columns = [
+    {
+        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) => data.metricValue !== null ? data.metricValue.toFixed(2) : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalSignals",
+        label: "Total Signals",
+        format: (data) => `${data.stats.totalSignals}`,
+        isVisible: () => true,
+    },
+    {
+        key: "winRate",
+        label: "Win Rate",
+        format: (data) => data.stats.winRate !== null
+            ? `${data.stats.winRate.toFixed(2)}%`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgPnl",
+        label: "Avg PNL",
+        format: (data) => data.stats.avgPnl !== null
+            ? `${data.stats.avgPnl > 0 ? "+" : ""}${data.stats.avgPnl.toFixed(2)}%`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalPnl",
+        label: "Total PNL",
+        format: (data) => data.stats.totalPnl !== null
+            ? `${data.stats.totalPnl > 0 ? "+" : ""}${data.stats.totalPnl.toFixed(2)}%`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "sharpeRatio",
+        label: "Sharpe Ratio",
+        format: (data) => data.stats.sharpeRatio !== null
+            ? `${data.stats.sharpeRatio.toFixed(3)}`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "stdDev",
+        label: "Std Dev",
+        format: (data) => data.stats.stdDev !== null
+            ? `${data.stats.stdDev.toFixed(3)}%`
+            : "N/A",
+        isVisible: () => true,
+    },
+];
+/**
+ * Column configuration for walker PNL table in markdown reports.
+ *
+ * Defines the table structure for displaying all closed signals across all strategies in walker backtest reports.
+ * Each column specifies how to format and display individual signal trade data.
+ *
+ * Used by {@link WalkerMarkdownService} to generate markdown tables showing:
+ * - Strategy identification for each signal
+ * - Signal details (signal ID, symbol, position)
+ * - Trade performance (PNL percentage, close reason)
+ * - Timing information (open time, close time)
+ *
+ * @remarks
+ * This configuration aggregates all signals from all tested strategies into a single comprehensive table.
+ * Useful for detailed analysis of individual trades across different strategy configurations.
+ *
+ * @example
+ * ```typescript
+ * import { walker_pnl_columns } from "./assets/walker.columns";
+ *
+ * // Use with WalkerMarkdownService for signal-level analysis
+ * const service = new WalkerMarkdownService();
+ * await service.getReport(
+ *   "my-walker",
+ *   "BTCUSDT",
+ *   "sharpeRatio",
+ *   { exchangeName: "binance", frameName: "1d" },
+ *   undefined, // use default strategy columns
+ *   walker_pnl_columns
+ * );
+ * ```
+ *
+ * @see {@link WalkerMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link SignalData} for data structure
+ */
+const walker_pnl_columns = [
+    {
+        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,
+    },
+];
+
+/**
+ * Mapping of available table/markdown reports to their column definitions.
+ *
+ * Each property references a column definition object imported from
+ * `src/assets/*.columns`. These are used by markdown/report generators
+ * (backtest, live, schedule, risk, heat, performance, partial, walker).
+ */
+const COLUMN_CONFIG = {
+    /** Columns used in backtest markdown tables and reports */
+    backtest_columns,
+    /** Columns used by heatmap / heat reports */
+    heat_columns,
+    /** Columns for live trading reports and logs */
+    live_columns,
+    /** Columns for partial-results / incremental reports */
+    partial_columns,
+    /** Columns for performance summary reports */
+    performance_columns,
+    /** Columns for risk-related reports */
+    risk_columns,
+    /** Columns for scheduled report output */
+    schedule_columns,
+    /** Walker: PnL summary columns */
+    walker_pnl_columns,
+    /** Walker: strategy-level summary columns */
+    walker_strategy_columns,
+};
+/**
+ * Immutable default columns mapping used across the application.
+ * Use `DEFAULT_COLUMNS` when you need a read-only reference to the
+ * canonical column configuration.
+ */
+const DEFAULT_COLUMNS = Object.freeze({ ...COLUMN_CONFIG });
+
 const { init, inject, provide } = diKit.createActivator("backtest");
 
 /**
@@ -221,6 +1296,7 @@ const validationServices$1 = {
     riskValidationService: Symbol('riskValidationService'),
     optimizerValidationService: Symbol('optimizerValidationService'),
     configValidationService: Symbol('configValidationService'),
+    columnValidationService: Symbol('columnValidationService'),
 };
 const templateServices$1 = {
     optimizerTemplateService: Symbol('optimizerTemplateService'),
@@ -1765,53 +2841,6 @@ var emitters = /*#__PURE__*/Object.freeze({
     walkerStopSubject: walkerStopSubject
 });
 
-/**
- * Converts markdown content to plain text with minimal formatting
- * @param content - Markdown string to convert
- * @returns Plain text representation
- */
-const toPlainString = (content) => {
-    if (!content) {
-        return "";
-    }
-    let text = content;
-    // Remove code blocks
-    text = text.replace(/```[\s\S]*?```/g, "");
-    text = text.replace(/`([^`]+)`/g, "$1");
-    // Remove images
-    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1");
-    // Convert links to text only (keep link text, remove URL)
-    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
-    // Remove headers (convert to plain text)
-    text = text.replace(/^#{1,6}\s+(.+)$/gm, "$1");
-    // Remove bold and italic markers
-    text = text.replace(/\*\*\*(.+?)\*\*\*/g, "$1");
-    text = text.replace(/\*\*(.+?)\*\*/g, "$1");
-    text = text.replace(/\*(.+?)\*/g, "$1");
-    text = text.replace(/___(.+?)___/g, "$1");
-    text = text.replace(/__(.+?)__/g, "$1");
-    text = text.replace(/_(.+?)_/g, "$1");
-    // Remove strikethrough
-    text = text.replace(/~~(.+?)~~/g, "$1");
-    // Convert lists to plain text with bullets
-    text = text.replace(/^\s*[-*+]\s+/gm, "• ");
-    text = text.replace(/^\s*\d+\.\s+/gm, "• ");
-    // Remove blockquotes
-    text = text.replace(/^\s*>\s+/gm, "");
-    // Remove horizontal rules
-    text = text.replace(/^(\*{3,}|-{3,}|_{3,})$/gm, "");
-    // Remove HTML tags
-    text = text.replace(/<[^>]+>/g, "");
-    // Remove excessive whitespace and normalize line breaks
-    text = text.replace(/\n[\s\n]*\n/g, "\n");
-    text = text.replace(/[ \t]+/g, " ");
-    // Remove all newline characters
-    text = text.replace(/\n/g, " ");
-    // Remove excessive spaces after newline removal
-    text = text.replace(/\s+/g, " ");
-    return text.trim();
-};
-
 const INTERVAL_MINUTES$1 = {
     "1m": 1,
     "3m": 3,
@@ -3390,7 +4419,7 @@ class RiskUtils {
          *
          * @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
+         * @returns Promise resolving to RiskStatisticsModel object with counts and event list
          *
          * @example
          * ```typescript
@@ -3437,6 +4466,7 @@ class RiskUtils {
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -3460,7 +4490,7 @@ class RiskUtils {
          * // - my-strategy: 1
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(RISK_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
@@ -3472,7 +4502,7 @@ class RiskUtils {
                     backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.riskMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.riskMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Generates and saves markdown report to file.
@@ -3489,6 +4519,7 @@ class RiskUtils {
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
          * @param path - Output directory path (default: "./dump/risk")
+         * @param columns - Optional columns configuration for the report
          * @returns Promise that resolves when file is written
          *
          * @example
@@ -3505,7 +4536,7 @@ class RiskUtils {
          * }
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(RISK_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
@@ -3518,7 +4549,7 @@ class RiskUtils {
                     backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_DUMP));
             }
-            await backtest$1.riskMarkdownService.dump(symbol, strategyName, path);
+            await backtest$1.riskMarkdownService.dump(symbol, strategyName, path, columns);
         };
     }
 }
@@ -5035,6 +6066,19 @@ class StrategySchemaService {
             if (typeof strategySchema.strategyName !== "string") {
                 throw new Error(`strategy schema validation failed: missing strategyName`);
             }
+            if (strategySchema.riskName && typeof strategySchema.riskName !== "string") {
+                throw new Error(`strategy schema validation failed: invalid riskName`);
+            }
+            if (strategySchema.riskList && !Array.isArray(strategySchema.riskList)) {
+                throw new Error(`strategy schema validation failed: invalid riskList for strategyName=${strategySchema.strategyName} system=${strategySchema.riskList}`);
+            }
+            if (strategySchema.riskList &&
+                strategySchema.riskList.length !== new Set(strategySchema.riskList).size) {
+                throw new Error(`strategy schema validation failed: found duplicate riskList for strategyName=${strategySchema.strategyName} riskList=[${strategySchema.riskList}]`);
+            }
+            if (strategySchema.riskList?.some((value) => typeof value !== "string")) {
+                throw new Error(`strategy schema validation failed: invalid riskList for strategyName=${strategySchema.strategyName} riskList=[${strategySchema.riskList}]`);
+            }
             if (typeof strategySchema.interval !== "string") {
                 throw new Error(`strategy schema validation failed: missing interval for strategyName=${strategySchema.strategyName}`);
             }
@@ -6265,178 +7309,91 @@ class BacktestCommandService {
          * @returns Async generator yielding closed signals with PNL
          */
         this.run = (symbol, context) => {
-            this.loggerService.log(METHOD_NAME_RUN$1, {
-                symbol,
-                context,
-            });
-            {
-                this.strategyValidationService.validate(context.strategyName, METHOD_NAME_RUN$1);
-                this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN$1);
-                this.frameValidationService.validate(context.frameName, METHOD_NAME_RUN$1);
-            }
-            {
-                const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
-                riskName && this.riskValidationService.validate(riskName, METHOD_NAME_RUN$1);
-                riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_RUN$1));
-            }
-            return this.backtestLogicPublicService.run(symbol, context);
-        };
-    }
-}
-
-const METHOD_NAME_RUN = "walkerCommandService run";
-/**
- * Global service providing access to walker functionality.
- *
- * Simple wrapper around WalkerLogicPublicService for dependency injection.
- * Used by public API exports.
- */
-class WalkerCommandService {
-    constructor() {
-        this.loggerService = inject(TYPES.loggerService);
-        this.walkerLogicPublicService = inject(TYPES.walkerLogicPublicService);
-        this.walkerSchemaService = inject(TYPES.walkerSchemaService);
-        this.strategyValidationService = inject(TYPES.strategyValidationService);
-        this.exchangeValidationService = inject(TYPES.exchangeValidationService);
-        this.frameValidationService = inject(TYPES.frameValidationService);
-        this.walkerValidationService = inject(TYPES.walkerValidationService);
-        this.strategySchemaService = inject(TYPES.strategySchemaService);
-        this.riskValidationService = inject(TYPES.riskValidationService);
-        /**
-         * Runs walker comparison for a symbol with context propagation.
-         *
-         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
-         * @param context - Walker context with strategies and metric
-         */
-        this.run = (symbol, context) => {
-            this.loggerService.log(METHOD_NAME_RUN, {
-                symbol,
-                context,
-            });
-            {
-                this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN);
-                this.frameValidationService.validate(context.frameName, METHOD_NAME_RUN);
-                this.walkerValidationService.validate(context.walkerName, METHOD_NAME_RUN);
-            }
-            {
-                const walkerSchema = this.walkerSchemaService.get(context.walkerName);
-                for (const strategyName of walkerSchema.strategies) {
-                    const { riskName, riskList } = this.strategySchemaService.get(strategyName);
-                    this.strategyValidationService.validate(strategyName, METHOD_NAME_RUN);
-                    riskName && this.riskValidationService.validate(riskName, METHOD_NAME_RUN);
-                    riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_RUN));
-                }
-            }
-            return this.walkerLogicPublicService.run(symbol, context);
-        };
-    }
-}
-
-/**
- * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
- *
- * @param value - Value to check
- * @returns true if value is unsafe, false otherwise
- */
-function isUnsafe$3(value) {
-    if (typeof value !== "number") {
-        return true;
-    }
-    if (isNaN(value)) {
-        return true;
-    }
-    if (!isFinite(value)) {
-        return true;
-    }
-    return false;
-}
-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",
-        label: "PNL (net)",
-        format: (data) => {
-            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",
-        label: "Duration (min)",
-        format: (data) => {
-            const durationMs = data.closeTimestamp - data.signal.pendingAt;
-            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,
-    },
-];
+            this.loggerService.log(METHOD_NAME_RUN$1, {
+                symbol,
+                context,
+            });
+            {
+                this.strategyValidationService.validate(context.strategyName, METHOD_NAME_RUN$1);
+                this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN$1);
+                this.frameValidationService.validate(context.frameName, METHOD_NAME_RUN$1);
+            }
+            {
+                const { riskName, riskList } = this.strategySchemaService.get(context.strategyName);
+                riskName && this.riskValidationService.validate(riskName, METHOD_NAME_RUN$1);
+                riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_RUN$1));
+            }
+            return this.backtestLogicPublicService.run(symbol, context);
+        };
+    }
+}
+
+const METHOD_NAME_RUN = "walkerCommandService run";
+/**
+ * Global service providing access to walker functionality.
+ *
+ * Simple wrapper around WalkerLogicPublicService for dependency injection.
+ * Used by public API exports.
+ */
+class WalkerCommandService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.walkerLogicPublicService = inject(TYPES.walkerLogicPublicService);
+        this.walkerSchemaService = inject(TYPES.walkerSchemaService);
+        this.strategyValidationService = inject(TYPES.strategyValidationService);
+        this.exchangeValidationService = inject(TYPES.exchangeValidationService);
+        this.frameValidationService = inject(TYPES.frameValidationService);
+        this.walkerValidationService = inject(TYPES.walkerValidationService);
+        this.strategySchemaService = inject(TYPES.strategySchemaService);
+        this.riskValidationService = inject(TYPES.riskValidationService);
+        /**
+         * Runs walker comparison for a symbol with context propagation.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Walker context with strategies and metric
+         */
+        this.run = (symbol, context) => {
+            this.loggerService.log(METHOD_NAME_RUN, {
+                symbol,
+                context,
+            });
+            {
+                this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN);
+                this.frameValidationService.validate(context.frameName, METHOD_NAME_RUN);
+                this.walkerValidationService.validate(context.walkerName, METHOD_NAME_RUN);
+            }
+            {
+                const walkerSchema = this.walkerSchemaService.get(context.walkerName);
+                for (const strategyName of walkerSchema.strategies) {
+                    const { riskName, riskList } = this.strategySchemaService.get(strategyName);
+                    this.strategyValidationService.validate(strategyName, METHOD_NAME_RUN);
+                    riskName && this.riskValidationService.validate(riskName, METHOD_NAME_RUN);
+                    riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_RUN));
+                }
+            }
+            return this.walkerLogicPublicService.run(symbol, context);
+        };
+    }
+}
+
+/**
+ * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
+ *
+ * @param value - Value to check
+ * @returns true if value is unsafe, false otherwise
+ */
+function isUnsafe$3(value) {
+    if (typeof value !== "number") {
+        return true;
+    }
+    if (isNaN(value)) {
+        return true;
+    }
+    if (!isFinite(value)) {
+        return true;
+    }
+    return false;
+}
 /** Maximum number of signals to store in backtest reports */
 const MAX_EVENTS$6 = 250;
 /**
@@ -6530,9 +7487,10 @@ let ReportStorage$5 = class ReportStorage {
      * Generates markdown report with all closed signals for a strategy (View).
      *
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all signals
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.backtest_columns) {
         const stats = await this.getData();
         if (stats.totalSignals === 0) {
             return [
@@ -6541,10 +7499,15 @@ let ReportStorage$5 = class ReportStorage {
                 "No signals closed yet."
             ].join("\n");
         }
-        const visibleColumns = columns$6.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._signalList.map((closedSignal) => visibleColumns.map((col) => col.format(closedSignal)));
+        const rows = await Promise.all(this._signalList.map(async (closedSignal, index) => Promise.all(visibleColumns.map((col) => col.format(closedSignal, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map(row => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -6569,9 +7532,10 @@ let ReportStorage$5 = class ReportStorage {
      *
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/backtest")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/backtest") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path$1 = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -6679,6 +7643,7 @@ class BacktestMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all closed signals
          *
          * @example
@@ -6688,13 +7653,13 @@ class BacktestMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.backtest_columns) => {
             this.loggerService.log("backtestMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -6704,6 +7669,7 @@ class BacktestMarkdownService {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/backtest")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -6716,14 +7682,14 @@ class BacktestMarkdownService {
          * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/backtest") => {
+        this.dump = async (symbol, strategyName, path = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) => {
             this.loggerService.log("backtestMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(strategyName, path);
+            await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated signal data from storage.
@@ -6791,104 +7757,6 @@ function isUnsafe$2(value) {
     }
     return false;
 }
-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",
-        label: "Take Profit",
-        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",
-        label: "PNL (net)",
-        format: (data) => {
-            if (data.pnl === undefined)
-                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$5 = 250;
 /**
@@ -7100,9 +7968,10 @@ let ReportStorage$4 = class ReportStorage {
      * Generates markdown report with all tick events for a strategy (View).
      *
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all events
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.live_columns) {
         const stats = await this.getData();
         if (stats.totalEvents === 0) {
             return [
@@ -7111,10 +7980,15 @@ let ReportStorage$4 = class ReportStorage {
                 "No events recorded yet."
             ].join("\n");
         }
-        const visibleColumns = columns$5.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
+        const rows = await Promise.all(this._eventList.map(async (event, index) => Promise.all(visibleColumns.map((col) => col.format(event, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map(row => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -7139,9 +8013,10 @@ let ReportStorage$4 = class ReportStorage {
      *
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/live")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/live") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path$1 = "./dump/live", columns = COLUMN_CONFIG.live_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -7262,6 +8137,7 @@ class LiveMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
@@ -7271,13 +8147,13 @@ class LiveMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.live_columns) => {
             this.loggerService.log("liveMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -7287,6 +8163,7 @@ class LiveMarkdownService {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/live")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -7299,14 +8176,14 @@ class LiveMarkdownService {
          * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/live") => {
+        this.dump = async (symbol, strategyName, path = "./dump/live", columns = COLUMN_CONFIG.live_columns) => {
             this.loggerService.log("liveMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(strategyName, path);
+            await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
@@ -7353,77 +8230,9 @@ class LiveMarkdownService {
             this.loggerService.log("liveMarkdownService init");
             signalLiveEmitter.subscribe(this.tick);
         });
-    }
-}
-
-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$4 = 250;
 /**
@@ -7568,9 +8377,10 @@ let ReportStorage$3 = class ReportStorage {
      * Generates markdown report with all scheduled events for a strategy (View).
      *
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all events
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.schedule_columns) {
         const stats = await this.getData();
         if (stats.totalEvents === 0) {
             return [
@@ -7579,10 +8389,15 @@ let ReportStorage$3 = class ReportStorage {
                 "No scheduled signals recorded yet."
             ].join("\n");
         }
-        const visibleColumns = columns$4.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
+        const rows = await Promise.all(this._eventList.map(async (event, index) => Promise.all(visibleColumns.map((col) => col.format(event, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -7605,9 +8420,10 @@ let ReportStorage$3 = class ReportStorage {
      *
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/schedule")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/schedule") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path$1 = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -7713,6 +8529,7 @@ class ScheduleMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
@@ -7722,13 +8539,13 @@ class ScheduleMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.schedule_columns) => {
             this.loggerService.log("scheduleMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -7738,6 +8555,7 @@ class ScheduleMarkdownService {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/schedule")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -7750,14 +8568,14 @@ class ScheduleMarkdownService {
          * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/schedule") => {
+        this.dump = async (symbol, strategyName, path = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) => {
             this.loggerService.log("scheduleMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(strategyName, path);
+            await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
@@ -7816,86 +8634,6 @@ 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$3 = 10000;
 /**
@@ -7998,9 +8736,10 @@ class PerformanceStorage {
      * Generates markdown report with performance statistics.
      *
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.performance_columns) {
         const stats = await this.getData(strategyName);
         if (stats.totalEvents === 0) {
             return [
@@ -8012,10 +8751,15 @@ 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 using Column interface
-        const visibleColumns = columns$3.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = sortedMetrics.map((metric) => visibleColumns.map((col) => col.format(metric)));
+        const rows = await Promise.all(sortedMetrics.map(async (metric, index) => Promise.all(visibleColumns.map((col) => col.format(metric, index)))));
         const tableData = [header, separator, ...rows];
         const summaryTable = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         // Calculate percentage of total time for each metric
@@ -8046,9 +8790,10 @@ class PerformanceStorage {
      *
      * @param strategyName - Strategy name
      * @param path - Directory path to save report
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/performance") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path$1 = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -8141,6 +8886,7 @@ class PerformanceMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string
          *
          * @example
@@ -8149,13 +8895,13 @@ class PerformanceMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.performance_columns) => {
             this.loggerService.log("performanceMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves performance report to disk.
@@ -8163,6 +8909,7 @@ class PerformanceMarkdownService {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -8173,14 +8920,14 @@ class PerformanceMarkdownService {
          * await performanceService.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/performance") => {
+        this.dump = async (symbol, strategyName, path = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) => {
             this.loggerService.log("performanceMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(strategyName, path);
+            await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated performance data from storage.
@@ -8239,135 +8986,6 @@ function formatMetric(value) {
     }
     return value.toFixed(2);
 }
-/**
- * Creates strategy comparison columns based on metric name.
- * Dynamically builds column configuration with metric-specific header.
- *
- * @param metric - Metric being optimized
- * @returns Array of column configurations for strategy comparison table
- */
-function createStrategyColumns(metric) {
-    return [
-        {
-            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",
-            label: "Win Rate",
-            format: (data) => data.stats.winRate !== null
-                ? `${data.stats.winRate.toFixed(2)}%`
-                : "N/A",
-            isVisible: () => true,
-        },
-        {
-            key: "avgPnl",
-            label: "Avg PNL",
-            format: (data) => data.stats.avgPnl !== null
-                ? `${data.stats.avgPnl > 0 ? "+" : ""}${data.stats.avgPnl.toFixed(2)}%`
-                : "N/A",
-            isVisible: () => true,
-        },
-        {
-            key: "totalPnl",
-            label: "Total PNL",
-            format: (data) => data.stats.totalPnl !== null
-                ? `${data.stats.totalPnl > 0 ? "+" : ""}${data.stats.totalPnl.toFixed(2)}%`
-                : "N/A",
-            isVisible: () => true,
-        },
-        {
-            key: "sharpeRatio",
-            label: "Sharpe Ratio",
-            format: (data) => data.stats.sharpeRatio !== null
-                ? `${data.stats.sharpeRatio.toFixed(3)}`
-                : "N/A",
-            isVisible: () => true,
-        },
-        {
-            key: "stdDev",
-            label: "Std Dev",
-            format: (data) => data.stats.stdDev !== null
-                ? `${data.stats.stdDev.toFixed(3)}%`
-                : "N/A",
-            isVisible: () => true,
-        },
-    ];
-}
-/**
- * Column configuration for PNL table.
- * Defines all columns for displaying closed signals across strategies.
- */
-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.
@@ -8399,7 +9017,7 @@ let ReportStorage$2 = class ReportStorage {
         this._strategyResults.unshift({
             strategyName: data.strategyName,
             stats: data.stats,
-            metricValue: data.metricValue,
+            metricValue: isUnsafe$1(data.metricValue) ? null : data.metricValue,
         });
     }
     /**
@@ -8432,11 +9050,11 @@ let ReportStorage$2 = class ReportStorage {
      * Generates comparison table for top N strategies (View).
      * Sorts strategies by metric value and formats as markdown table.
      *
-     * @param metric - Metric being optimized
      * @param topN - Number of top strategies to include (default: 10)
+     * @param columns - Column configuration for formatting the strategy comparison table
      * @returns Markdown formatted comparison table
      */
-    getComparisonTable(metric, topN = 10) {
+    async getComparisonTable(topN = 10, columns = COLUMN_CONFIG.walker_strategy_columns) {
         if (this._strategyResults.length === 0) {
             return "No strategy results available.";
         }
@@ -8449,13 +9067,17 @@ let ReportStorage$2 = class ReportStorage {
         // Take top N strategies
         const topStrategies = sortedResults.slice(0, topN);
         // Get columns configuration
-        const columns = createStrategyColumns(metric);
-        const visibleColumns = columns.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         // Build table header
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
         // Build table rows
-        const rows = topStrategies.map((result, index) => visibleColumns.map((col) => col.format(result, index)));
+        const rows = await Promise.all(topStrategies.map(async (result, index) => Promise.all(visibleColumns.map((col) => col.format(result, index)))));
         const tableData = [header, separator, ...rows];
         return tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
     }
@@ -8463,9 +9085,10 @@ let ReportStorage$2 = class ReportStorage {
      * Generates PNL table showing all closed signals across all strategies (View).
      * Collects all signals from all strategies and formats as markdown table.
      *
+     * @param columns - Column configuration for formatting the PNL table
      * @returns Markdown formatted PNL table
      */
-    getPnlTable() {
+    async getPnlTable(columns = COLUMN_CONFIG.walker_pnl_columns) {
         if (this._strategyResults.length === 0) {
             return "No strategy results available.";
         }
@@ -8489,11 +9112,16 @@ let ReportStorage$2 = class ReportStorage {
             return "No closed signals available.";
         }
         // Build table header
-        const visibleColumns = pnlColumns.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
         // Build table rows
-        const rows = allSignals.map((signal) => visibleColumns.map((col) => col.format(signal)));
+        const rows = await Promise.all(allSignals.map(async (signal, index) => Promise.all(visibleColumns.map((col) => col.format(signal, index)))));
         const tableData = [header, separator, ...rows];
         return tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
     }
@@ -8504,9 +9132,11 @@ let ReportStorage$2 = class ReportStorage {
      * @param symbol - Trading symbol
      * @param metric - Metric being optimized
      * @param context - Context with exchangeName and frameName
+     * @param strategyColumns - Column configuration for strategy comparison table
+     * @param pnlColumns - Column configuration for PNL table
      * @returns Markdown formatted report with all results
      */
-    async getReport(symbol, metric, context) {
+    async getReport(symbol, metric, context, strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) {
         const results = await this.getData(symbol, metric, context);
         // Get total signals for best strategy
         const bestStrategySignals = results.bestStats?.totalSignals ?? 0;
@@ -8526,11 +9156,11 @@ let ReportStorage$2 = class ReportStorage {
             "",
             "## Top Strategies Comparison",
             "",
-            this.getComparisonTable(metric, 10),
+            await this.getComparisonTable(10, strategyColumns),
             "",
             "## All Signals (PNL Table)",
             "",
-            this.getPnlTable(),
+            await this.getPnlTable(pnlColumns),
             "",
             "**Note:** Higher values are better for all metrics except Standard Deviation (lower is better)."
         ].join("\n");
@@ -8542,9 +9172,11 @@ let ReportStorage$2 = class ReportStorage {
      * @param metric - Metric being optimized
      * @param context - Context with exchangeName and frameName
      * @param path - Directory path to save report (default: "./dump/walker")
+     * @param strategyColumns - Column configuration for strategy comparison table
+     * @param pnlColumns - Column configuration for PNL table
      */
-    async dump(symbol, metric, context, path$1 = "./dump/walker") {
-        const markdown = await this.getReport(symbol, metric, context);
+    async dump(symbol, metric, context, path$1 = "./dump/walker", strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) {
+        const markdown = await this.getReport(symbol, metric, context, strategyColumns, pnlColumns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -8637,6 +9269,8 @@ class WalkerMarkdownService {
          * @param symbol - Trading symbol
          * @param metric - Metric being optimized
          * @param context - Context with exchangeName and frameName
+         * @param strategyColumns - Column configuration for strategy comparison table
+         * @param pnlColumns - Column configuration for PNL table
          * @returns Markdown formatted report string
          *
          * @example
@@ -8646,7 +9280,7 @@ class WalkerMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (walkerName, symbol, metric, context) => {
+        this.getReport = async (walkerName, symbol, metric, context, strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) => {
             this.loggerService.log("walkerMarkdownService getReport", {
                 walkerName,
                 symbol,
@@ -8654,7 +9288,7 @@ class WalkerMarkdownService {
                 context,
             });
             const storage = this.getStorage(walkerName);
-            return storage.getReport(symbol, metric, context);
+            return storage.getReport(symbol, metric, context, strategyColumns, pnlColumns);
         };
         /**
          * Saves walker report to disk.
@@ -8666,6 +9300,8 @@ class WalkerMarkdownService {
          * @param metric - Metric being optimized
          * @param context - Context with exchangeName and frameName
          * @param path - Directory path to save report (default: "./dump/walker")
+         * @param strategyColumns - Column configuration for strategy comparison table
+         * @param pnlColumns - Column configuration for PNL table
          *
          * @example
          * ```typescript
@@ -8678,7 +9314,7 @@ class WalkerMarkdownService {
          * await service.dump("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" }, "./custom/path");
          * ```
          */
-        this.dump = async (walkerName, symbol, metric, context, path = "./dump/walker") => {
+        this.dump = async (walkerName, symbol, metric, context, path = "./dump/walker", strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) => {
             this.loggerService.log("walkerMarkdownService dump", {
                 walkerName,
                 symbol,
@@ -8687,7 +9323,7 @@ class WalkerMarkdownService {
                 path,
             });
             const storage = this.getStorage(walkerName);
-            await storage.dump(symbol, metric, context, path);
+            await storage.dump(symbol, metric, context, path, strategyColumns, pnlColumns);
         };
         /**
          * Clears accumulated result data from storage.
@@ -8734,99 +9370,25 @@ class WalkerMarkdownService {
 const HEATMAP_METHOD_NAME_GET_DATA = "HeatMarkdownService.getData";
 const HEATMAP_METHOD_NAME_GET_REPORT = "HeatMarkdownService.getReport";
 const HEATMAP_METHOD_NAME_DUMP = "HeatMarkdownService.dump";
-const HEATMAP_METHOD_NAME_CLEAR = "HeatMarkdownService.clear";
-/**
- * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
- *
- * @param value - Value to check
- * @returns true if value is unsafe, false otherwise
- */
-function isUnsafe(value) {
-    if (typeof value !== "number") {
-        return true;
-    }
-    if (isNaN(value)) {
-        return true;
-    }
-    if (!isFinite(value)) {
-        return true;
-    }
-    return false;
-}
-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,
-    },
-];
+const HEATMAP_METHOD_NAME_CLEAR = "HeatMarkdownService.clear";
+/**
+ * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
+ *
+ * @param value - Value to check
+ * @returns true if value is unsafe, false otherwise
+ */
+function isUnsafe(value) {
+    if (typeof value !== "number") {
+        return true;
+    }
+    if (isNaN(value)) {
+        return true;
+    }
+    if (!isFinite(value)) {
+        return true;
+    }
+    return false;
+}
 /** Maximum number of signals to store per symbol in heatmap reports */
 const MAX_EVENTS$2 = 250;
 /**
@@ -9061,9 +9623,10 @@ class HeatmapStorage {
      * Generates markdown report with portfolio heatmap table (View).
      *
      * @param strategyName - Strategy name for report title
+     * @param columns - Column configuration for formatting the table
      * @returns Promise resolving to markdown formatted report string
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.heat_columns) {
         const data = await this.getData();
         if (data.symbols.length === 0) {
             return [
@@ -9072,10 +9635,15 @@ class HeatmapStorage {
                 "*No data available*"
             ].join("\n");
         }
-        const visibleColumns = columns$2.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = data.symbols.map((row) => visibleColumns.map((col) => col.format(row)));
+        const rows = await Promise.all(data.symbols.map(async (row, index) => Promise.all(visibleColumns.map((col) => col.format(row, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -9091,9 +9659,10 @@ class HeatmapStorage {
      *
      * @param strategyName - Strategy name for filename
      * @param path - Directory path to save report (default: "./dump/heatmap")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/heatmap") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path$1 = "./dump/heatmap", columns = COLUMN_CONFIG.heat_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -9190,6 +9759,7 @@ class HeatMarkdownService {
          * Generates markdown report with portfolio heatmap table for a strategy.
          *
          * @param strategyName - Strategy name to generate heatmap report for
+         * @param columns - Column configuration for formatting the table
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -9209,12 +9779,12 @@ class HeatMarkdownService {
          * // ...
          * ```
          */
-        this.getReport = async (strategyName) => {
+        this.getReport = async (strategyName, columns = COLUMN_CONFIG.heat_columns) => {
             this.loggerService.log(HEATMAP_METHOD_NAME_GET_REPORT, {
                 strategyName,
             });
             const storage = this.getStorage(strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves heatmap report to disk for a strategy.
@@ -9224,6 +9794,7 @@ class HeatMarkdownService {
          *
          * @param strategyName - Strategy name to save heatmap report for
          * @param path - Optional directory path to save report (default: "./dump/heatmap")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -9236,13 +9807,13 @@ class HeatMarkdownService {
          * await service.dump("my-strategy", "./reports");
          * ```
          */
-        this.dump = async (strategyName, path = "./dump/heatmap") => {
+        this.dump = async (strategyName, path = "./dump/heatmap", columns = COLUMN_CONFIG.heat_columns) => {
             this.loggerService.log(HEATMAP_METHOD_NAME_DUMP, {
                 strategyName,
                 path,
             });
             const storage = this.getStorage(strategyName);
-            await storage.dump(strategyName, path);
+            await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated heatmap data from storage.
@@ -11633,62 +12204,6 @@ class PartialConnectionService {
     }
 }
 
-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$1 = 250;
 /**
@@ -11778,9 +12293,10 @@ let ReportStorage$1 = class ReportStorage {
      *
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all events
      */
-    async getReport(symbol, strategyName) {
+    async getReport(symbol, strategyName, columns = COLUMN_CONFIG.partial_columns) {
         const stats = await this.getData();
         if (stats.totalEvents === 0) {
             return [
@@ -11789,10 +12305,15 @@ let ReportStorage$1 = class ReportStorage {
                 "No partial profit/loss events recorded yet."
             ].join("\n");
         }
-        const visibleColumns = columns$1.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
+        const rows = await Promise.all(this._eventList.map(async (event, index) => Promise.all(visibleColumns.map((col) => col.format(event, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -11811,9 +12332,10 @@ let ReportStorage$1 = class ReportStorage {
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/partial")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(symbol, strategyName, path$1 = "./dump/partial") {
-        const markdown = await this.getReport(symbol, strategyName);
+    async dump(symbol, strategyName, path$1 = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) {
+        const markdown = await this.getReport(symbol, strategyName, columns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -11924,6 +12446,7 @@ class PartialMarkdownService {
          *
          * @param symbol - Trading pair symbol to generate report for
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
@@ -11933,13 +12456,13 @@ class PartialMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.partial_columns) => {
             this.loggerService.log("partialMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(symbol, strategyName);
+            return storage.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -11949,6 +12472,7 @@ class PartialMarkdownService {
          * @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/partial")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -11961,14 +12485,14 @@ class PartialMarkdownService {
          * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/partial") => {
+        this.dump = async (symbol, strategyName, path = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) => {
             this.loggerService.log("partialMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(symbol, strategyName, path);
+            await storage.dump(symbol, strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
@@ -12428,92 +12952,6 @@ 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;
 /**
@@ -12569,9 +13007,10 @@ class ReportStorage {
      *
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all events
      */
-    async getReport(symbol, strategyName) {
+    async getReport(symbol, strategyName, columns = COLUMN_CONFIG.risk_columns) {
         const stats = await this.getData();
         if (stats.totalRejections === 0) {
             return [
@@ -12580,10 +13019,15 @@ class ReportStorage {
                 "No risk rejections recorded yet.",
             ].join("\n");
         }
-        const visibleColumns = columns.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
+        const rows = await Promise.all(this._eventList.map(async (event, index) => Promise.all(visibleColumns.map((col) => col.format(event, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -12606,9 +13050,10 @@ class ReportStorage {
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/risk")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(symbol, strategyName, path$1 = "./dump/risk") {
-        const markdown = await this.getReport(symbol, strategyName);
+    async dump(symbol, strategyName, path$1 = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) {
+        const markdown = await this.getReport(symbol, strategyName, columns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -12700,6 +13145,7 @@ class RiskMarkdownService {
          *
          * @param symbol - Trading pair symbol to generate report for
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
@@ -12709,13 +13155,13 @@ class RiskMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.risk_columns) => {
             this.loggerService.log("riskMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(symbol, strategyName);
+            return storage.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -12725,6 +13171,7 @@ class RiskMarkdownService {
          * @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")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -12737,14 +13184,14 @@ class RiskMarkdownService {
          * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/risk") => {
+        this.dump = async (symbol, strategyName, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) => {
             this.loggerService.log("riskMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(symbol, strategyName, path);
+            await storage.dump(symbol, strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
@@ -12794,6 +13241,118 @@ class RiskMarkdownService {
     }
 }
 
+/**
+ * Service for validating column configurations to ensure consistency with ColumnModel interface
+ * and prevent invalid column definitions.
+ *
+ * Performs comprehensive validation on all column definitions in COLUMN_CONFIG:
+ * - **Required fields**: All columns must have key, label, format, and isVisible properties
+ * - **Unique keys**: All key values must be unique within each column collection
+ * - **Function validation**: format and isVisible must be callable functions
+ * - **Data types**: key and label must be non-empty strings
+ *
+ * @throws {Error} If any validation fails, throws with detailed breakdown of all errors
+ *
+ * @example
+ * ```typescript
+ * const validator = new ColumnValidationService();
+ * validator.validate(); // Throws if column configuration is invalid
+ * ```
+ *
+ * @example Validation failure output:
+ * ```
+ * Column configuration validation failed:
+ *   1. backtest_columns[0]: Missing required field "format"
+ *   2. heat_columns: Duplicate key "symbol" at indexes 1, 5
+ *   3. live_columns[3].isVisible must be a function, got "boolean"
+ * ```
+ */
+class ColumnValidationService {
+    constructor() {
+        /**
+         * @private
+         * @readonly
+         * Injected logger service instance
+         */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Validates all column configurations in COLUMN_CONFIG for structural correctness.
+         *
+         * Checks:
+         * 1. All required fields (key, label, format, isVisible) are present in each column
+         * 2. key and label are non-empty strings
+         * 3. format and isVisible are functions (not other types)
+         * 4. All keys are unique within each column collection
+         *
+         * @throws Error if configuration is invalid
+         */
+        this.validate = () => {
+            this.loggerService.log("columnValidationService validate");
+            const errors = [];
+            // Iterate through all column collections in COLUMN_CONFIG
+            for (const [configKey, columns] of Object.entries(COLUMN_CONFIG)) {
+                if (!Array.isArray(columns)) {
+                    errors.push(`${configKey} is not an array, got ${typeof columns}`);
+                    continue;
+                }
+                // Track keys for uniqueness check
+                const keyMap = new Map();
+                // Validate each column in the collection
+                columns.forEach((column, index) => {
+                    if (!column || typeof column !== "object") {
+                        errors.push(`${configKey}[${index}]: Column must be an object, got ${typeof column}`);
+                        return;
+                    }
+                    // Check for all required fields
+                    const requiredFields = ["key", "label", "format", "isVisible"];
+                    for (const field of requiredFields) {
+                        if (!(field in column)) {
+                            errors.push(`${configKey}[${index}]: Missing required field "${field}"`);
+                        }
+                    }
+                    // Validate key and label are non-empty strings
+                    if (typeof column.key !== "string" || column.key.trim() === "") {
+                        errors.push(`${configKey}[${index}].key must be a non-empty string, got ${typeof column.key === "string" ? `"${column.key}"` : typeof column.key}`);
+                    }
+                    else {
+                        // Track key for uniqueness check
+                        if (!keyMap.has(column.key)) {
+                            keyMap.set(column.key, []);
+                        }
+                        keyMap.get(column.key).push(index);
+                    }
+                    if (typeof column.label !== "string" || column.label.trim() === "") {
+                        errors.push(`${configKey}[${index}].label must be a non-empty string, got ${typeof column.label === "string" ? `"${column.label}"` : typeof column.label}`);
+                    }
+                    // Validate format is a function
+                    if (typeof column.format !== "function") {
+                        errors.push(`${configKey}[${index}].format must be a function, got "${typeof column.format}"`);
+                    }
+                    // Validate isVisible is a function
+                    if (typeof column.isVisible !== "function") {
+                        errors.push(`${configKey}[${index}].isVisible must be a function, got "${typeof column.isVisible}"`);
+                    }
+                });
+                // Check for duplicate keys
+                for (const [key, indexes] of keyMap.entries()) {
+                    if (indexes.length > 1) {
+                        errors.push(`${configKey}: Duplicate key "${key}" at indexes ${indexes.join(", ")}`);
+                    }
+                }
+            }
+            // Throw aggregated errors if any
+            if (errors.length > 0) {
+                const errorMessage = `Column configuration validation failed:\n${errors
+                    .map((e, i) => `  ${i + 1}. ${e}`)
+                    .join("\n")}`;
+                this.loggerService.warn(errorMessage);
+                throw new Error(errorMessage);
+            }
+            this.loggerService.log("columnValidationService validation passed");
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -12865,6 +13424,7 @@ class RiskMarkdownService {
     provide(TYPES.riskValidationService, () => new RiskValidationService());
     provide(TYPES.optimizerValidationService, () => new OptimizerValidationService());
     provide(TYPES.configValidationService, () => new ConfigValidationService());
+    provide(TYPES.columnValidationService, () => new ColumnValidationService());
 }
 {
     provide(TYPES.optimizerTemplateService, () => new OptimizerTemplateService());
@@ -12941,6 +13501,7 @@ const validationServices = {
     riskValidationService: inject(TYPES.riskValidationService),
     optimizerValidationService: inject(TYPES.optimizerValidationService),
     configValidationService: inject(TYPES.configValidationService),
+    columnValidationService: inject(TYPES.columnValidationService),
 };
 const templateServices = {
     optimizerTemplateService: inject(TYPES.optimizerTemplateService),
@@ -13040,6 +13601,77 @@ function getConfig() {
 function getDefaultConfig() {
     return DEFAULT_CONFIG;
 }
+/**
+ * Sets custom column configurations for markdown report generation.
+ *
+ * Allows overriding default column definitions for any report type.
+ * All columns are validated before assignment to ensure structural correctness.
+ *
+ * @param columns - Partial column configuration object to override default column settings
+ * @param _unsafe - Skip column validations - required for testbed
+ *
+ * @example
+ * ```typescript
+ * setColumns({
+ *   backtest_columns: [
+ *     {
+ *       key: "customId",
+ *       label: "Custom ID",
+ *       format: (data) => data.signal.id,
+ *       isVisible: () => true
+ *     }
+ *   ],
+ * });
+ * ```
+ *
+ * @throws {Error} If column configuration is invalid
+ */
+function setColumns(columns, _unsafe) {
+    const prevConfig = Object.assign({}, COLUMN_CONFIG);
+    try {
+        Object.assign(COLUMN_CONFIG, columns);
+        !_unsafe && backtest$1.columnValidationService.validate();
+    }
+    catch (error) {
+        console.warn(`backtest-kit setColumns failed: ${functoolsKit.getErrorMessage(error)}`, columns);
+        Object.assign(COLUMN_CONFIG, prevConfig);
+        throw error;
+    }
+}
+/**
+ * Retrieves a copy of the current column configuration for markdown report generation.
+ *
+ * Returns a shallow copy of the current COLUMN_CONFIG to prevent accidental mutations.
+ * Use this to inspect the current column definitions without modifying them.
+ *
+ * @returns {ColumnConfig} A copy of the current column configuration object
+ *
+ * @example
+ * ```typescript
+ * const currentColumns = getColumns();
+ * console.log(currentColumns.backtest_columns.length);
+ * ```
+ */
+function getColumns() {
+    return Object.assign({}, COLUMN_CONFIG);
+}
+/**
+ * Retrieves the default column configuration object for markdown report generation.
+ *
+ * Returns a reference to the default column definitions with all preset values.
+ * Use this to see what column options are available and their default definitions.
+ *
+ * @returns {ColumnConfig} The default column configuration object
+ *
+ * @example
+ * ```typescript
+ * const defaultColumns = getDefaultColumns();
+ * console.log(defaultColumns.backtest_columns);
+ * ```
+ */
+function getDefaultColumns() {
+    return DEFAULT_COLUMNS;
+}
 
 const ADD_STRATEGY_METHOD_NAME = "add.addStrategy";
 const ADD_EXCHANGE_METHOD_NAME = "add.addExchange";
@@ -15025,6 +15657,7 @@ class BacktestInstance {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15034,12 +15667,12 @@ class BacktestInstance {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
             });
-            return await backtest$1.backtestMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.backtestMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15047,6 +15680,7 @@ class BacktestInstance {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/backtest")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15058,13 +15692,13 @@ class BacktestInstance {
          * await instance.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(BACKTEST_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
                 path,
             });
-            await backtest$1.backtestMarkdownService.dump(symbol, strategyName, path);
+            await backtest$1.backtestMarkdownService.dump(symbol, strategyName, path, columns);
         };
     }
 }
@@ -15203,6 +15837,7 @@ class BacktestUtils {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15211,7 +15846,7 @@ class BacktestUtils {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -15219,7 +15854,7 @@ class BacktestUtils {
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, strategyName);
-            return await instance.getReport(symbol, strategyName);
+            return await instance.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15227,6 +15862,7 @@ class BacktestUtils {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/backtest")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15237,7 +15873,7 @@ class BacktestUtils {
          * await Backtest.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -15245,7 +15881,7 @@ class BacktestUtils {
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_DUMP));
             }
             const instance = this._getInstance(symbol, strategyName);
-            return await instance.dump(symbol, strategyName, path);
+            return await instance.dump(symbol, strategyName, path, columns);
         };
         /**
          * Lists all active backtest instances with their current status.
@@ -15525,6 +16161,7 @@ class LiveInstance {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15534,12 +16171,12 @@ class LiveInstance {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
             });
-            return await backtest$1.liveMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.liveMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15547,6 +16184,7 @@ class LiveInstance {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/live")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15558,13 +16196,13 @@ class LiveInstance {
          * await instance.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(LIVE_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
                 path,
             });
-            await backtest$1.liveMarkdownService.dump(symbol, strategyName, path);
+            await backtest$1.liveMarkdownService.dump(symbol, strategyName, path, columns);
         };
     }
 }
@@ -15714,6 +16352,7 @@ class LiveUtils {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15722,7 +16361,7 @@ class LiveUtils {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -15730,7 +16369,7 @@ class LiveUtils {
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, strategyName);
-            return await instance.getReport(symbol, strategyName);
+            return await instance.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15738,6 +16377,7 @@ class LiveUtils {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/live")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15748,7 +16388,7 @@ class LiveUtils {
          * await Live.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -15756,7 +16396,7 @@ class LiveUtils {
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP));
             }
             const instance = this._getInstance(symbol, strategyName);
-            return await instance.dump(symbol, strategyName, path);
+            return await instance.dump(symbol, strategyName, path, columns);
         };
         /**
          * Lists all active live trading instances with their current status.
@@ -15855,6 +16495,7 @@ class ScheduleUtils {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15863,7 +16504,7 @@ class ScheduleUtils {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
@@ -15874,7 +16515,7 @@ class ScheduleUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.scheduleMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.scheduleMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15882,6 +16523,7 @@ class ScheduleUtils {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/schedule")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15892,7 +16534,7 @@ class ScheduleUtils {
          * await Schedule.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
@@ -15904,7 +16546,7 @@ class ScheduleUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP));
             }
-            await backtest$1.scheduleMarkdownService.dump(symbol, strategyName, path);
+            await backtest$1.scheduleMarkdownService.dump(symbol, strategyName, path, columns);
         };
     }
 }
@@ -16004,6 +16646,7 @@ class Performance {
      *
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name to generate report for
+     * @param columns - Optional columns configuration for the report
      * @returns Markdown formatted report string
      *
      * @example
@@ -16016,14 +16659,14 @@ class Performance {
      * await fs.writeFile("performance-report.md", markdown);
      * ```
      */
-    static async getReport(symbol, strategyName) {
+    static async getReport(symbol, strategyName, columns) {
         backtest$1.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_GET_REPORT);
         {
             const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
             riskName && backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT);
             riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT));
         }
-        return backtest$1.performanceMarkdownService.getReport(symbol, strategyName);
+        return backtest$1.performanceMarkdownService.getReport(symbol, strategyName, columns);
     }
     /**
      * Saves performance report to disk.
@@ -16034,6 +16677,7 @@ class Performance {
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name to save report for
      * @param path - Optional custom directory path
+     * @param columns - Optional columns configuration for the report
      *
      * @example
      * ```typescript
@@ -16044,14 +16688,14 @@ class Performance {
      * await Performance.dump("BTCUSDT", "my-strategy", "./reports/perf");
      * ```
      */
-    static async dump(symbol, strategyName, path = "./dump/performance") {
+    static async dump(symbol, strategyName, path = "./dump/performance", columns) {
         backtest$1.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_DUMP);
         {
             const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
             riskName && backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP);
             riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_DUMP));
         }
-        return backtest$1.performanceMarkdownService.dump(symbol, strategyName, path);
+        return backtest$1.performanceMarkdownService.dump(symbol, strategyName, path, columns);
     }
 }
 
@@ -16313,6 +16957,8 @@ class WalkerInstance {
          *
          * @param symbol - Trading symbol
          * @param walkerName - Walker name to generate report for
+         * @param strategyColumns - Optional strategy columns configuration
+         * @param pnlColumns - Optional PNL columns configuration
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -16322,7 +16968,7 @@ class WalkerInstance {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, walkerName) => {
+        this.getReport = async (symbol, walkerName, strategyColumns, pnlColumns) => {
             backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_REPORT, {
                 symbol,
                 walkerName,
@@ -16331,7 +16977,7 @@ class WalkerInstance {
             return await backtest$1.walkerMarkdownService.getReport(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
-            });
+            }, strategyColumns, pnlColumns);
         };
         /**
          * Saves walker report to disk.
@@ -16339,6 +16985,8 @@ class WalkerInstance {
          * @param symbol - Trading symbol
          * @param walkerName - Walker name to save report for
          * @param path - Optional directory path to save report (default: "./dump/walker")
+         * @param strategyColumns - Optional strategy columns configuration
+         * @param pnlColumns - Optional PNL columns configuration
          *
          * @example
          * ```typescript
@@ -16350,7 +16998,7 @@ class WalkerInstance {
          * await instance.dump("BTCUSDT", "my-walker", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, walkerName, path) => {
+        this.dump = async (symbol, walkerName, path, strategyColumns, pnlColumns) => {
             backtest$1.loggerService.info(WALKER_METHOD_NAME_DUMP, {
                 symbol,
                 walkerName,
@@ -16360,7 +17008,7 @@ class WalkerInstance {
             await backtest$1.walkerMarkdownService.dump(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
-            }, path);
+            }, path, strategyColumns, pnlColumns);
         };
     }
 }
@@ -16509,6 +17157,8 @@ class WalkerUtils {
          *
          * @param symbol - Trading symbol
          * @param walkerName - Walker name to generate report for
+         * @param strategyColumns - Optional strategy columns configuration
+         * @param pnlColumns - Optional PNL columns configuration
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -16517,7 +17167,7 @@ class WalkerUtils {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, walkerName) => {
+        this.getReport = async (symbol, walkerName, strategyColumns, pnlColumns) => {
             backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_GET_REPORT);
             const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
@@ -16527,7 +17177,7 @@ class WalkerUtils {
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, walkerName);
-            return await instance.getReport(symbol, walkerName);
+            return await instance.getReport(symbol, walkerName, strategyColumns, pnlColumns);
         };
         /**
          * Saves walker report to disk.
@@ -16535,6 +17185,8 @@ class WalkerUtils {
          * @param symbol - Trading symbol
          * @param walkerName - Walker name to save report for
          * @param path - Optional directory path to save report (default: "./dump/walker")
+         * @param strategyColumns - Optional strategy columns configuration
+         * @param pnlColumns - Optional PNL columns configuration
          *
          * @example
          * ```typescript
@@ -16545,7 +17197,7 @@ class WalkerUtils {
          * await Walker.dump("BTCUSDT", "my-walker", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, walkerName, path) => {
+        this.dump = async (symbol, walkerName, path, strategyColumns, pnlColumns) => {
             backtest$1.walkerValidationService.validate(walkerName, WALKER_METHOD_NAME_DUMP);
             const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
@@ -16555,7 +17207,7 @@ class WalkerUtils {
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP));
             }
             const instance = this._getInstance(symbol, walkerName);
-            return await instance.dump(symbol, walkerName, path);
+            return await instance.dump(symbol, walkerName, path, strategyColumns, pnlColumns);
         };
         /**
          * Lists all active walker instances with their current status.
@@ -16661,6 +17313,7 @@ class HeatUtils {
          * Symbols are sorted by Total PNL descending.
          *
          * @param strategyName - Strategy name to generate heatmap report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -16679,7 +17332,7 @@ class HeatUtils {
          * // ...
          * ```
          */
-        this.getReport = async (strategyName) => {
+        this.getReport = async (strategyName, columns) => {
             backtest$1.loggerService.info(HEAT_METHOD_NAME_GET_REPORT, { strategyName });
             backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_GET_REPORT);
             {
@@ -16687,7 +17340,7 @@ class HeatUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.heatMarkdownService.getReport(strategyName);
+            return await backtest$1.heatMarkdownService.getReport(strategyName, columns);
         };
         /**
          * Saves heatmap report to disk for a strategy.
@@ -16697,6 +17350,7 @@ class HeatUtils {
          *
          * @param strategyName - Strategy name to save heatmap report for
          * @param path - Optional directory path to save report (default: "./dump/heatmap")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -16707,7 +17361,7 @@ class HeatUtils {
          * await Heat.dump("my-strategy", "./reports");
          * ```
          */
-        this.dump = async (strategyName, path) => {
+        this.dump = async (strategyName, path, columns) => {
             backtest$1.loggerService.info(HEAT_METHOD_NAME_DUMP, { strategyName, path });
             backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_DUMP);
             {
@@ -16715,7 +17369,7 @@ class HeatUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP));
             }
-            await backtest$1.heatMarkdownService.dump(strategyName, path);
+            await backtest$1.heatMarkdownService.dump(strategyName, path, columns);
         };
     }
 }
@@ -17015,7 +17669,7 @@ class PartialUtils {
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
-         * @returns Promise resolving to PartialStatistics object with counts and event list
+         * @returns Promise resolving to PartialStatisticsModel object with counts and event list
          *
          * @example
          * ```typescript
@@ -17059,6 +17713,7 @@ class PartialUtils {
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -17079,7 +17734,7 @@ class PartialUtils {
          * // **Loss events:** 1
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol, strategyName });
             backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_GET_REPORT);
             {
@@ -17087,7 +17742,7 @@ class PartialUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.partialMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.partialMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Generates and saves markdown report to file.
@@ -17104,6 +17759,7 @@ class PartialUtils {
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
          * @param path - Output directory path (default: "./dump/partial")
+         * @param columns - Optional columns configuration for the report
          * @returns Promise that resolves when file is written
          *
          * @example
@@ -17120,7 +17776,7 @@ class PartialUtils {
          * }
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, strategyName, path });
             backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_DUMP);
             {
@@ -17128,7 +17784,7 @@ class PartialUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP));
             }
-            await backtest$1.partialMarkdownService.dump(symbol, strategyName, path);
+            await backtest$1.partialMarkdownService.dump(symbol, strategyName, path, columns);
         };
     }
 }
@@ -17260,8 +17916,10 @@ exports.formatPrice = formatPrice;
 exports.formatQuantity = formatQuantity;
 exports.getAveragePrice = getAveragePrice;
 exports.getCandles = getCandles;
+exports.getColumns = getColumns;
 exports.getConfig = getConfig;
 exports.getDate = getDate;
+exports.getDefaultColumns = getDefaultColumns;
 exports.getDefaultConfig = getDefaultConfig;
 exports.getMode = getMode;
 exports.lib = backtest;
@@ -17300,5 +17958,6 @@ exports.listenWalker = listenWalker;
 exports.listenWalkerComplete = listenWalkerComplete;
 exports.listenWalkerOnce = listenWalkerOnce;
 exports.listenWalkerProgress = listenWalkerProgress;
+exports.setColumns = setColumns;
 exports.setConfig = setConfig;
 exports.setLogger = setLogger;