backtest-kit 1.5.24 → 1.5.26

package/build/index.mjs

@@ -1,4 +1,4 @@
-import { errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, ToolRegistry, isObject, and, resolveDocuments, str, iterateDocuments, distinctDocuments, queued, singlerun } from 'functools-kit';
+import { str, errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, ToolRegistry, isObject, and, resolveDocuments, iterateDocuments, distinctDocuments, queued, singlerun } from 'functools-kit';
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
 import fs, { mkdir, writeFile } from 'fs/promises';
@@ -120,6 +120,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 ? str(data.totalPnl, "%+.2f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "sharpeRatio",
+        label: "Sharpe",
+        format: (data) => data.sharpeRatio !== null ? str(data.sharpeRatio, "%.2f") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "profitFactor",
+        label: "PF",
+        format: (data) => data.profitFactor !== null ? str(data.profitFactor, "%.2f") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "expectancy",
+        label: "Expect",
+        format: (data) => data.expectancy !== null ? str(data.expectancy, "%+.2f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "winRate",
+        label: "WR",
+        format: (data) => data.winRate !== null ? str(data.winRate, "%.1f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgWin",
+        label: "Avg Win",
+        format: (data) => data.avgWin !== null ? str(data.avgWin, "%+.2f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgLoss",
+        label: "Avg Loss",
+        format: (data) => data.avgLoss !== null ? str(data.avgLoss, "%+.2f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "maxDrawdown",
+        label: "Max DD",
+        format: (data) => data.maxDrawdown !== null ? 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 } = createActivator("backtest");
 
 /**
@@ -219,6 +1294,7 @@ const validationServices$1 = {
     riskValidationService: Symbol('riskValidationService'),
     optimizerValidationService: Symbol('optimizerValidationService'),
     configValidationService: Symbol('configValidationService'),
+    columnValidationService: Symbol('columnValidationService'),
 };
 const templateServices$1 = {
     optimizerTemplateService: Symbol('optimizerTemplateService'),
@@ -1763,53 +2839,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,
@@ -3388,7 +4417,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
@@ -3435,6 +4464,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
@@ -3458,7 +4488,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,
@@ -3470,7 +4500,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.
@@ -3487,6 +4517,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
@@ -3503,7 +4534,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,
@@ -3516,7 +4547,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);
         };
     }
 }
@@ -5033,6 +6064,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}`);
             }
@@ -6263,178 +7307,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;
 /**
@@ -6528,9 +7485,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 [
@@ -6539,10 +7497,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 [
@@ -6567,9 +7530,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 = "./dump/backtest") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -6677,6 +7641,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
@@ -6686,13 +7651,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.
@@ -6702,6 +7667,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
@@ -6714,14 +7680,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.
@@ -6789,104 +7755,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;
 /**
@@ -7098,9 +7966,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 [
@@ -7109,10 +7978,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 [
@@ -7137,9 +8011,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 = "./dump/live") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path = "./dump/live", columns = COLUMN_CONFIG.live_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -7260,6 +8135,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
@@ -7269,13 +8145,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.
@@ -7285,6 +8161,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
@@ -7297,14 +8174,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.
@@ -7351,77 +8228,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;
 /**
@@ -7566,9 +8375,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 [
@@ -7577,10 +8387,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 [
@@ -7603,9 +8418,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 = "./dump/schedule") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -7711,6 +8527,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
@@ -7720,13 +8537,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.
@@ -7736,6 +8553,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
@@ -7748,14 +8566,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.
@@ -7814,86 +8632,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;
 /**
@@ -7996,9 +8734,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 [
@@ -8010,10 +8749,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
@@ -8044,9 +8788,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 = "./dump/performance") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -8139,6 +8884,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
@@ -8147,13 +8893,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.
@@ -8161,6 +8907,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
@@ -8171,14 +8918,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.
@@ -8237,135 +8984,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.
@@ -8397,7 +9015,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,
         });
     }
     /**
@@ -8430,11 +9048,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.";
         }
@@ -8447,13 +9065,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");
     }
@@ -8461,9 +9083,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.";
         }
@@ -8487,11 +9110,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");
     }
@@ -8502,9 +9130,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;
@@ -8524,11 +9154,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");
@@ -8540,9 +9170,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 = "./dump/walker") {
-        const markdown = await this.getReport(symbol, metric, context);
+    async dump(symbol, metric, context, path = "./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 = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -8635,6 +9267,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
@@ -8644,7 +9278,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,
@@ -8652,7 +9286,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.
@@ -8664,6 +9298,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
@@ -8676,7 +9312,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,
@@ -8685,7 +9321,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.
@@ -8732,99 +9368,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 ? str(data.totalPnl, "%+.2f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "sharpeRatio",
-        label: "Sharpe",
-        format: (data) => data.sharpeRatio !== null ? str(data.sharpeRatio, "%.2f") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "profitFactor",
-        label: "PF",
-        format: (data) => data.profitFactor !== null ? str(data.profitFactor, "%.2f") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "expectancy",
-        label: "Expect",
-        format: (data) => data.expectancy !== null ? str(data.expectancy, "%+.2f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "winRate",
-        label: "WR",
-        format: (data) => data.winRate !== null ? str(data.winRate, "%.1f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "avgWin",
-        label: "Avg Win",
-        format: (data) => data.avgWin !== null ? str(data.avgWin, "%+.2f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "avgLoss",
-        label: "Avg Loss",
-        format: (data) => data.avgLoss !== null ? str(data.avgLoss, "%+.2f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "maxDrawdown",
-        label: "Max DD",
-        format: (data) => data.maxDrawdown !== null ? 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;
 /**
@@ -9059,9 +9621,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 [
@@ -9070,10 +9633,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 [
@@ -9089,9 +9657,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 = "./dump/heatmap") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path = "./dump/heatmap", columns = COLUMN_CONFIG.heat_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -9188,6 +9757,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
@@ -9207,12 +9777,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.
@@ -9222,6 +9792,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
@@ -9234,13 +9805,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.
@@ -11631,62 +12202,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;
 /**
@@ -11776,9 +12291,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 [
@@ -11787,10 +12303,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 [
@@ -11809,9 +12330,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 = "./dump/partial") {
-        const markdown = await this.getReport(symbol, strategyName);
+    async dump(symbol, strategyName, path = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) {
+        const markdown = await this.getReport(symbol, strategyName, columns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -11922,6 +12444,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
@@ -11931,13 +12454,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.
@@ -11947,6 +12470,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
@@ -11959,14 +12483,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.
@@ -12426,92 +12950,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;
 /**
@@ -12567,9 +13005,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 [
@@ -12578,10 +13017,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 [
@@ -12604,9 +13048,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 = "./dump/risk") {
-        const markdown = await this.getReport(symbol, strategyName);
+    async dump(symbol, strategyName, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) {
+        const markdown = await this.getReport(symbol, strategyName, columns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -12698,6 +13143,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
@@ -12707,13 +13153,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.
@@ -12723,6 +13169,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
@@ -12735,14 +13182,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.
@@ -12792,6 +13239,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());
 }
@@ -12863,6 +13422,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());
@@ -12939,6 +13499,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),
@@ -13038,6 +13599,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: ${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";
@@ -15023,6 +15655,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
@@ -15032,12 +15665,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.
@@ -15045,6 +15678,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
@@ -15056,13 +15690,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);
         };
     }
 }
@@ -15201,6 +15835,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
@@ -15209,7 +15844,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);
@@ -15217,7 +15852,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.
@@ -15225,6 +15860,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
@@ -15235,7 +15871,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);
@@ -15243,7 +15879,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.
@@ -15523,6 +16159,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
@@ -15532,12 +16169,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.
@@ -15545,6 +16182,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
@@ -15556,13 +16194,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);
         };
     }
 }
@@ -15712,6 +16350,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
@@ -15720,7 +16359,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);
@@ -15728,7 +16367,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.
@@ -15736,6 +16375,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
@@ -15746,7 +16386,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);
@@ -15754,7 +16394,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.
@@ -15853,6 +16493,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
@@ -15861,7 +16502,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,
@@ -15872,7 +16513,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.
@@ -15880,6 +16521,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
@@ -15890,7 +16532,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,
@@ -15902,7 +16544,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);
         };
     }
 }
@@ -16002,6 +16644,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
@@ -16014,14 +16657,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.
@@ -16032,6 +16675,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
@@ -16042,14 +16686,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);
     }
 }
 
@@ -16311,6 +16955,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
@@ -16320,7 +16966,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,
@@ -16329,7 +16975,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.
@@ -16337,6 +16983,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
@@ -16348,7 +16996,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,
@@ -16358,7 +17006,7 @@ class WalkerInstance {
             await backtest$1.walkerMarkdownService.dump(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
-            }, path);
+            }, path, strategyColumns, pnlColumns);
         };
     }
 }
@@ -16507,6 +17155,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
@@ -16515,7 +17165,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) {
@@ -16525,7 +17175,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.
@@ -16533,6 +17183,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
@@ -16543,7 +17195,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) {
@@ -16553,7 +17205,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.
@@ -16659,6 +17311,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
@@ -16677,7 +17330,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);
             {
@@ -16685,7 +17338,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.
@@ -16695,6 +17348,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
@@ -16705,7 +17359,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);
             {
@@ -16713,7 +17367,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);
         };
     }
 }
@@ -17013,7 +17667,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
@@ -17057,6 +17711,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
@@ -17077,7 +17732,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);
             {
@@ -17085,7 +17740,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.
@@ -17102,6 +17757,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
@@ -17118,7 +17774,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);
             {
@@ -17126,7 +17782,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);
         };
     }
 }
@@ -17227,4 +17883,4 @@ class ConstantUtils {
  */
 const Constant = new ConstantUtils();
 
-export { Backtest, Constant, ExecutionContextService, Heat, Live, MethodContextService, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getConfig, getDate, getDefaultConfig, getMode, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setConfig, setLogger };
+export { Backtest, Constant, ExecutionContextService, Heat, Live, MethodContextService, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getColumns, getConfig, getDate, getDefaultColumns, getDefaultConfig, getMode, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setColumns, setConfig, setLogger };