backtest-kit 1.5.25 → 1.5.27

package/build/index.cjs

@@ -122,6 +122,1081 @@ const GLOBAL_CONFIG = {
 };
 const DEFAULT_CONFIG = Object.freeze({ ...GLOBAL_CONFIG });
 
+/**
+ * Converts markdown content to plain text with minimal formatting
+ * @param content - Markdown string to convert
+ * @returns Plain text representation
+ */
+const toPlainString = (content) => {
+    if (!content) {
+        return "";
+    }
+    let text = content;
+    // Remove code blocks
+    text = text.replace(/```[\s\S]*?```/g, "");
+    text = text.replace(/`([^`]+)`/g, "$1");
+    // Remove images
+    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1");
+    // Convert links to text only (keep link text, remove URL)
+    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    // Remove headers (convert to plain text)
+    text = text.replace(/^#{1,6}\s+(.+)$/gm, "$1");
+    // Remove bold and italic markers
+    text = text.replace(/\*\*\*(.+?)\*\*\*/g, "$1");
+    text = text.replace(/\*\*(.+?)\*\*/g, "$1");
+    text = text.replace(/\*(.+?)\*/g, "$1");
+    text = text.replace(/___(.+?)___/g, "$1");
+    text = text.replace(/__(.+?)__/g, "$1");
+    text = text.replace(/_(.+?)_/g, "$1");
+    // Remove strikethrough
+    text = text.replace(/~~(.+?)~~/g, "$1");
+    // Convert lists to plain text with bullets
+    text = text.replace(/^\s*[-*+]\s+/gm, "• ");
+    text = text.replace(/^\s*\d+\.\s+/gm, "• ");
+    // Remove blockquotes
+    text = text.replace(/^\s*>\s+/gm, "");
+    // Remove horizontal rules
+    text = text.replace(/^(\*{3,}|-{3,}|_{3,})$/gm, "");
+    // Remove HTML tags
+    text = text.replace(/<[^>]+>/g, "");
+    // Remove excessive whitespace and normalize line breaks
+    text = text.replace(/\n[\s\n]*\n/g, "\n");
+    text = text.replace(/[ \t]+/g, " ");
+    // Remove all newline characters
+    text = text.replace(/\n/g, " ");
+    // Remove excessive spaces after newline removal
+    text = text.replace(/\s+/g, " ");
+    return text.trim();
+};
+
+/**
+ * Column configuration for backtest markdown reports.
+ *
+ * Defines the table structure for displaying closed trading signals in backtest reports.
+ * Each column specifies how to format and display specific signal data fields.
+ *
+ * Used by {@link BacktestMarkdownService} to generate markdown tables showing:
+ * - Signal identification (ID, symbol, position)
+ * - Price levels (open, close, take profit, stop loss)
+ * - Performance metrics (PNL percentage, close reason)
+ * - Timing information (duration, timestamps)
+ *
+ * @remarks
+ * Columns can be conditionally visible based on {@link GLOBAL_CONFIG} settings.
+ * For example, the "note" column visibility is controlled by `CC_REPORT_SHOW_SIGNAL_NOTE`.
+ *
+ * @example
+ * ```typescript
+ * import { backtest_columns } from "./assets/backtest.columns";
+ *
+ * // Use with BacktestMarkdownService
+ * const service = new BacktestMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", backtest_columns);
+ *
+ * // Or customize columns
+ * const customColumns = backtest_columns.filter(col => col.key !== "note");
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link BacktestMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link IStrategyTickResultClosed} for data structure
+ */
+const backtest_columns = [
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.signal.id,
+        isVisible: () => true,
+    },
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.signal.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.signal.position.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "note",
+        label: "Note",
+        format: (data) => toPlainString(data.signal.note ?? "N/A"),
+        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
+    },
+    {
+        key: "openPrice",
+        label: "Open Price",
+        format: (data) => `${data.signal.priceOpen.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "closePrice",
+        label: "Close Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "takeProfit",
+        label: "Take Profit",
+        format: (data) => `${data.signal.priceTakeProfit.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "stopLoss",
+        label: "Stop Loss",
+        format: (data) => `${data.signal.priceStopLoss.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "pnl",
+        label: "PNL (net)",
+        format: (data) => {
+            const pnlPercentage = data.pnl.pnlPercentage;
+            return `${pnlPercentage > 0 ? "+" : ""}${pnlPercentage.toFixed(2)}%`;
+        },
+        isVisible: () => true,
+    },
+    {
+        key: "closeReason",
+        label: "Close Reason",
+        format: (data) => data.closeReason,
+        isVisible: () => true,
+    },
+    {
+        key: "duration",
+        label: "Duration (min)",
+        format: (data) => {
+            const durationMs = data.closeTimestamp - data.signal.pendingAt;
+            const durationMin = Math.round(durationMs / 60000);
+            return `${durationMin}`;
+        },
+        isVisible: () => true,
+    },
+    {
+        key: "openTimestamp",
+        label: "Open Time",
+        format: (data) => new Date(data.signal.pendingAt).toISOString(),
+        isVisible: () => true,
+    },
+    {
+        key: "closeTimestamp",
+        label: "Close Time",
+        format: (data) => new Date(data.closeTimestamp).toISOString(),
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Column configuration for portfolio heatmap markdown reports.
+ *
+ * Defines the table structure for displaying aggregated per-symbol statistics in portfolio heatmap reports.
+ * Each column specifies how to format and display portfolio performance metrics across different trading symbols.
+ *
+ * Used by {@link HeatMarkdownService} to generate markdown tables showing:
+ * - Symbol identification
+ * - Performance metrics (Total PNL, Sharpe Ratio, Profit Factor, Expectancy)
+ * - Risk metrics (Win Rate, Average Win/Loss, Max Drawdown)
+ * - Trading activity (Total Trades, Win/Loss Streaks)
+ *
+ * @remarks
+ * This configuration is used to create portfolio-wide views that aggregate statistics per symbol.
+ * The heatmap service automatically sorts symbols by Sharpe Ratio (best performers first).
+ *
+ * @example
+ * ```typescript
+ * import { heat_columns } from "./assets/heat.columns";
+ *
+ * // Use with HeatMarkdownService
+ * const service = new HeatMarkdownService();
+ * await service.getReport("my-strategy", heat_columns);
+ *
+ * // Or customize to show only key metrics
+ * const customColumns = heat_columns.filter(col =>
+ *   ["symbol", "totalPnl", "sharpeRatio", "totalTrades"].includes(col.key)
+ * );
+ * await service.getReport("my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link HeatMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link IHeatmapRow} for data structure
+ */
+const heat_columns = [
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "totalPnl",
+        label: "Total PNL",
+        format: (data) => data.totalPnl !== null ? functoolsKit.str(data.totalPnl, "%+.2f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "sharpeRatio",
+        label: "Sharpe",
+        format: (data) => data.sharpeRatio !== null ? functoolsKit.str(data.sharpeRatio, "%.2f") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "profitFactor",
+        label: "PF",
+        format: (data) => data.profitFactor !== null ? functoolsKit.str(data.profitFactor, "%.2f") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "expectancy",
+        label: "Expect",
+        format: (data) => data.expectancy !== null ? functoolsKit.str(data.expectancy, "%+.2f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "winRate",
+        label: "WR",
+        format: (data) => data.winRate !== null ? functoolsKit.str(data.winRate, "%.1f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgWin",
+        label: "Avg Win",
+        format: (data) => data.avgWin !== null ? functoolsKit.str(data.avgWin, "%+.2f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgLoss",
+        label: "Avg Loss",
+        format: (data) => data.avgLoss !== null ? functoolsKit.str(data.avgLoss, "%+.2f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "maxDrawdown",
+        label: "Max DD",
+        format: (data) => data.maxDrawdown !== null ? functoolsKit.str(-data.maxDrawdown, "%.2f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "maxWinStreak",
+        label: "W Streak",
+        format: (data) => data.maxWinStreak.toString(),
+        isVisible: () => true,
+    },
+    {
+        key: "maxLossStreak",
+        label: "L Streak",
+        format: (data) => data.maxLossStreak.toString(),
+        isVisible: () => true,
+    },
+    {
+        key: "totalTrades",
+        label: "Trades",
+        format: (data) => data.totalTrades.toString(),
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Column configuration for live trading markdown reports.
+ *
+ * Defines the table structure for displaying real-time trading events in live trading reports.
+ * Each column specifies how to format and display live trading event data fields.
+ *
+ * Used by {@link LiveMarkdownService} to generate markdown tables showing:
+ * - Event information (timestamp, action type)
+ * - Signal identification (symbol, signal ID, position)
+ * - Price data (current price, open price, take profit, stop loss)
+ * - Performance metrics (PNL percentage, close reason, duration)
+ * - Position tracking (percentage to TP/SL)
+ *
+ * @remarks
+ * This configuration tracks all event types: idle, opened, active, and closed signals.
+ * The "note" column visibility is controlled by {@link GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE}.
+ *
+ * @example
+ * ```typescript
+ * import { live_columns } from "./assets/live.columns";
+ *
+ * // Use with LiveMarkdownService
+ * const service = new LiveMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", live_columns);
+ *
+ * // Or customize for minimal display
+ * const customColumns = live_columns.filter(col =>
+ *   ["timestamp", "action", "symbol", "pnl"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link LiveMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link TickEvent} for data structure
+ */
+const live_columns = [
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+        isVisible: () => true,
+    },
+    {
+        key: "action",
+        label: "Action",
+        format: (data) => data.action.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol ?? "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.signalId ?? "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.position?.toUpperCase() ?? "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "note",
+        label: "Note",
+        format: (data) => toPlainString(data.note ?? "N/A"),
+        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
+    },
+    {
+        key: "currentPrice",
+        label: "Current Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "openPrice",
+        label: "Open Price",
+        format: (data) => data.openPrice !== undefined ? `${data.openPrice.toFixed(8)} USD` : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "takeProfit",
+        label: "Take Profit",
+        format: (data) => data.takeProfit !== undefined
+            ? `${data.takeProfit.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "stopLoss",
+        label: "Stop Loss",
+        format: (data) => data.stopLoss !== undefined ? `${data.stopLoss.toFixed(8)} USD` : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "percentTp",
+        label: "% to TP",
+        format: (data) => data.percentTp !== undefined ? `${data.percentTp.toFixed(2)}%` : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "percentSl",
+        label: "% to SL",
+        format: (data) => data.percentSl !== undefined ? `${data.percentSl.toFixed(2)}%` : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "pnl",
+        label: "PNL (net)",
+        format: (data) => {
+            if (data.pnl === undefined)
+                return "N/A";
+            return `${data.pnl > 0 ? "+" : ""}${data.pnl.toFixed(2)}%`;
+        },
+        isVisible: () => true,
+    },
+    {
+        key: "closeReason",
+        label: "Close Reason",
+        format: (data) => data.closeReason ?? "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "duration",
+        label: "Duration (min)",
+        format: (data) => data.duration !== undefined ? `${data.duration}` : "N/A",
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Column configuration for partial profit/loss markdown reports.
+ *
+ * Defines the table structure for displaying partial position exit events in trading reports.
+ * Each column specifies how to format and display partial profit and loss level events.
+ *
+ * Used by {@link PartialMarkdownService} to generate markdown tables showing:
+ * - Event information (action type: profit or loss)
+ * - Signal identification (symbol, strategy name, signal ID, position)
+ * - Exit level information (percentage level reached)
+ * - Price data (current price at partial exit)
+ * - Timing information (timestamp, mode: backtest or live)
+ *
+ * @remarks
+ * This configuration tracks partial position exits at predefined profit/loss levels.
+ * The "note" column visibility is controlled by {@link GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE}.
+ * Useful for analyzing risk management strategies and partial exit performance.
+ *
+ * @example
+ * ```typescript
+ * import { partial_columns } from "./assets/partial.columns";
+ *
+ * // Use with PartialMarkdownService
+ * const service = new PartialMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", partial_columns);
+ *
+ * // Or customize to show only key fields
+ * const customColumns = partial_columns.filter(col =>
+ *   ["action", "symbol", "level", "timestamp"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link PartialMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link PartialEvent} for data structure
+ */
+const partial_columns = [
+    {
+        key: "action",
+        label: "Action",
+        format: (data) => data.action.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "strategyName",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+        isVisible: () => true,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.signalId,
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.position.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "level",
+        label: "Level %",
+        format: (data) => data.action === "profit" ? `+${data.level}%` : `-${data.level}%`,
+        isVisible: () => true,
+    },
+    {
+        key: "currentPrice",
+        label: "Current Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+        isVisible: () => true,
+    },
+    {
+        key: "mode",
+        label: "Mode",
+        format: (data) => (data.backtest ? "Backtest" : "Live"),
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Column configuration for performance metrics markdown reports.
+ *
+ * Defines the table structure for displaying performance statistics and timing metrics in performance reports.
+ * Each column specifies how to format and display aggregated performance data for different metric types.
+ *
+ * Used by {@link PerformanceMarkdownService} to generate markdown tables showing:
+ * - Metric identification (metric type)
+ * - Execution statistics (count, total duration, average, min, max)
+ * - Distribution metrics (standard deviation, median, percentiles)
+ * - Wait time statistics (average, min, max wait times between events)
+ *
+ * @remarks
+ * This configuration helps identify performance bottlenecks in strategy execution.
+ * The service automatically sorts metrics by total duration to highlight the slowest operations.
+ * All durations are measured in milliseconds.
+ *
+ * @example
+ * ```typescript
+ * import { performance_columns } from "./assets/performance.columns";
+ *
+ * // Use with PerformanceMarkdownService
+ * const service = new PerformanceMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", performance_columns);
+ *
+ * // Or customize for bottleneck analysis
+ * const customColumns = performance_columns.filter(col =>
+ *   ["metricType", "count", "avgDuration", "maxDuration", "p95"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link PerformanceMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link MetricStats} for data structure
+ */
+const performance_columns = [
+    {
+        key: "metricType",
+        label: "Metric Type",
+        format: (data) => data.metricType,
+        isVisible: () => true,
+    },
+    {
+        key: "count",
+        label: "Count",
+        format: (data) => data.count.toString(),
+        isVisible: () => true,
+    },
+    {
+        key: "totalDuration",
+        label: "Total (ms)",
+        format: (data) => data.totalDuration.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "avgDuration",
+        label: "Avg (ms)",
+        format: (data) => data.avgDuration.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "minDuration",
+        label: "Min (ms)",
+        format: (data) => data.minDuration.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "maxDuration",
+        label: "Max (ms)",
+        format: (data) => data.maxDuration.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "stdDev",
+        label: "Std Dev (ms)",
+        format: (data) => data.stdDev.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "median",
+        label: "Median (ms)",
+        format: (data) => data.median.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "p95",
+        label: "P95 (ms)",
+        format: (data) => data.p95.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "p99",
+        label: "P99 (ms)",
+        format: (data) => data.p99.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "avgWaitTime",
+        label: "Avg Wait (ms)",
+        format: (data) => data.avgWaitTime.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "minWaitTime",
+        label: "Min Wait (ms)",
+        format: (data) => data.minWaitTime.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "maxWaitTime",
+        label: "Max Wait (ms)",
+        format: (data) => data.maxWaitTime.toFixed(2),
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Column configuration for risk management markdown reports.
+ *
+ * Defines the table structure for displaying risk rejection events in risk management reports.
+ * Each column specifies how to format and display signals that were rejected due to risk limits.
+ *
+ * Used by {@link RiskMarkdownService} to generate markdown tables showing:
+ * - Signal identification (symbol, strategy name, signal ID, position)
+ * - Exchange information (exchange name, active position count)
+ * - Price data (open price, take profit, stop loss, current price)
+ * - Rejection details (rejection reason/comment, timestamp)
+ *
+ * @remarks
+ * This configuration helps analyze when and why the risk management system rejected signals.
+ * The "note" column visibility is controlled by {@link GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE}.
+ * Useful for tuning risk parameters and understanding risk control effectiveness.
+ *
+ * @example
+ * ```typescript
+ * import { risk_columns } from "./assets/risk.columns";
+ *
+ * // Use with RiskMarkdownService
+ * const service = new RiskMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", risk_columns);
+ *
+ * // Or customize to focus on rejection reasons
+ * const customColumns = risk_columns.filter(col =>
+ *   ["symbol", "strategyName", "comment", "activePositionCount", "timestamp"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link RiskMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link RiskEvent} for data structure
+ */
+const risk_columns = [
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "strategyName",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+        isVisible: () => true,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.pendingSignal.id || "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.pendingSignal.position.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "note",
+        label: "Note",
+        format: (data) => toPlainString(data.pendingSignal.note ?? "N/A"),
+        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
+    },
+    {
+        key: "exchangeName",
+        label: "Exchange",
+        format: (data) => data.exchangeName,
+        isVisible: () => true,
+    },
+    {
+        key: "openPrice",
+        label: "Open Price",
+        format: (data) => data.pendingSignal.priceOpen !== undefined
+            ? `${data.pendingSignal.priceOpen.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "takeProfit",
+        label: "Take Profit",
+        format: (data) => data.pendingSignal.priceTakeProfit !== undefined
+            ? `${data.pendingSignal.priceTakeProfit.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "stopLoss",
+        label: "Stop Loss",
+        format: (data) => data.pendingSignal.priceStopLoss !== undefined
+            ? `${data.pendingSignal.priceStopLoss.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "currentPrice",
+        label: "Current Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "activePositionCount",
+        label: "Active Positions",
+        format: (data) => data.activePositionCount.toString(),
+        isVisible: () => true,
+    },
+    {
+        key: "comment",
+        label: "Reason",
+        format: (data) => data.comment,
+        isVisible: () => true,
+    },
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Column configuration for scheduled signals markdown reports.
+ *
+ * Defines the table structure for displaying scheduled, opened, and cancelled signal events.
+ * Each column specifies how to format and display signal scheduling and activation data.
+ *
+ * Used by {@link ScheduleMarkdownService} to generate markdown tables showing:
+ * - Event information (timestamp, action: scheduled/opened/cancelled)
+ * - Signal identification (symbol, signal ID, position)
+ * - Price data (current price, entry price, take profit, stop loss)
+ * - Timing information (wait time in minutes before activation or cancellation)
+ *
+ * @remarks
+ * This configuration tracks the lifecycle of scheduled signals from creation to activation or cancellation.
+ * The "note" column visibility is controlled by {@link GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE}.
+ * Helps analyze signal scheduling effectiveness and cancellation patterns.
+ *
+ * @example
+ * ```typescript
+ * import { schedule_columns } from "./assets/schedule.columns";
+ *
+ * // Use with ScheduleMarkdownService
+ * const service = new ScheduleMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", schedule_columns);
+ *
+ * // Or customize for timing analysis
+ * const customColumns = schedule_columns.filter(col =>
+ *   ["timestamp", "action", "symbol", "duration"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link ScheduleMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link ScheduledEvent} for data structure
+ */
+const schedule_columns = [
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+        isVisible: () => true,
+    },
+    {
+        key: "action",
+        label: "Action",
+        format: (data) => data.action.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.signalId,
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.position.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "note",
+        label: "Note",
+        format: (data) => toPlainString(data.note ?? "N/A"),
+        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
+    },
+    {
+        key: "currentPrice",
+        label: "Current Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "priceOpen",
+        label: "Entry Price",
+        format: (data) => `${data.priceOpen.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "takeProfit",
+        label: "Take Profit",
+        format: (data) => `${data.takeProfit.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "stopLoss",
+        label: "Stop Loss",
+        format: (data) => `${data.stopLoss.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "duration",
+        label: "Wait Time (min)",
+        format: (data) => data.duration !== undefined ? `${data.duration}` : "N/A",
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Column configuration for walker strategy comparison table in markdown reports.
+ *
+ * Defines the table structure for displaying strategy comparison results in walker backtest reports.
+ * Each column specifies how to format and display aggregated strategy performance metrics.
+ *
+ * Used by {@link WalkerMarkdownService} to generate markdown tables showing:
+ * - Strategy ranking and identification
+ * - Optimization metric value (generic "Metric" column)
+ * - Performance statistics (Total Signals, Win Rate, Average PNL, Total PNL)
+ * - Risk metrics (Sharpe Ratio, Standard Deviation)
+ *
+ * @remarks
+ * This configuration is used in walker reports to compare multiple strategy configurations.
+ * The "Metric" column displays the value of the metric being optimized (Sharpe, PNL, etc.).
+ * Strategies are automatically sorted by metric value (best performers first).
+ *
+ * @example
+ * ```typescript
+ * import { walker_strategy_columns } from "./assets/walker.columns";
+ *
+ * // Use with WalkerMarkdownService for strategy comparison
+ * const service = new WalkerMarkdownService();
+ * await service.getReport(
+ *   "my-walker",
+ *   "BTCUSDT",
+ *   "sharpeRatio",
+ *   { exchangeName: "binance", frameName: "1d" },
+ *   walker_strategy_columns
+ * );
+ * ```
+ *
+ * @see {@link WalkerMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link IStrategyResult} for data structure
+ */
+const walker_strategy_columns = [
+    {
+        key: "rank",
+        label: "Rank",
+        format: (_data, index) => `${index + 1}`,
+        isVisible: () => true,
+    },
+    {
+        key: "strategy",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+        isVisible: () => true,
+    },
+    {
+        key: "metric",
+        label: "Metric",
+        format: (data) => data.metricValue !== null ? data.metricValue.toFixed(2) : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalSignals",
+        label: "Total Signals",
+        format: (data) => `${data.stats.totalSignals}`,
+        isVisible: () => true,
+    },
+    {
+        key: "winRate",
+        label: "Win Rate",
+        format: (data) => data.stats.winRate !== null
+            ? `${data.stats.winRate.toFixed(2)}%`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgPnl",
+        label: "Avg PNL",
+        format: (data) => data.stats.avgPnl !== null
+            ? `${data.stats.avgPnl > 0 ? "+" : ""}${data.stats.avgPnl.toFixed(2)}%`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalPnl",
+        label: "Total PNL",
+        format: (data) => data.stats.totalPnl !== null
+            ? `${data.stats.totalPnl > 0 ? "+" : ""}${data.stats.totalPnl.toFixed(2)}%`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "sharpeRatio",
+        label: "Sharpe Ratio",
+        format: (data) => data.stats.sharpeRatio !== null
+            ? `${data.stats.sharpeRatio.toFixed(3)}`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "stdDev",
+        label: "Std Dev",
+        format: (data) => data.stats.stdDev !== null
+            ? `${data.stats.stdDev.toFixed(3)}%`
+            : "N/A",
+        isVisible: () => true,
+    },
+];
+/**
+ * Column configuration for walker PNL table in markdown reports.
+ *
+ * Defines the table structure for displaying all closed signals across all strategies in walker backtest reports.
+ * Each column specifies how to format and display individual signal trade data.
+ *
+ * Used by {@link WalkerMarkdownService} to generate markdown tables showing:
+ * - Strategy identification for each signal
+ * - Signal details (signal ID, symbol, position)
+ * - Trade performance (PNL percentage, close reason)
+ * - Timing information (open time, close time)
+ *
+ * @remarks
+ * This configuration aggregates all signals from all tested strategies into a single comprehensive table.
+ * Useful for detailed analysis of individual trades across different strategy configurations.
+ *
+ * @example
+ * ```typescript
+ * import { walker_pnl_columns } from "./assets/walker.columns";
+ *
+ * // Use with WalkerMarkdownService for signal-level analysis
+ * const service = new WalkerMarkdownService();
+ * await service.getReport(
+ *   "my-walker",
+ *   "BTCUSDT",
+ *   "sharpeRatio",
+ *   { exchangeName: "binance", frameName: "1d" },
+ *   undefined, // use default strategy columns
+ *   walker_pnl_columns
+ * );
+ * ```
+ *
+ * @see {@link WalkerMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link SignalData} for data structure
+ */
+const walker_pnl_columns = [
+    {
+        key: "strategy",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+        isVisible: () => true,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.signalId,
+        isVisible: () => true,
+    },
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.position.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "pnl",
+        label: "PNL (net)",
+        format: (data) => `${data.pnl > 0 ? "+" : ""}${data.pnl.toFixed(2)}%`,
+        isVisible: () => true,
+    },
+    {
+        key: "closeReason",
+        label: "Close Reason",
+        format: (data) => data.closeReason,
+        isVisible: () => true,
+    },
+    {
+        key: "openTime",
+        label: "Open Time",
+        format: (data) => new Date(data.openTime).toISOString(),
+        isVisible: () => true,
+    },
+    {
+        key: "closeTime",
+        label: "Close Time",
+        format: (data) => new Date(data.closeTime).toISOString(),
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Mapping of available table/markdown reports to their column definitions.
+ *
+ * Each property references a column definition object imported from
+ * `src/assets/*.columns`. These are used by markdown/report generators
+ * (backtest, live, schedule, risk, heat, performance, partial, walker).
+ */
+const COLUMN_CONFIG = {
+    /** Columns used in backtest markdown tables and reports */
+    backtest_columns,
+    /** Columns used by heatmap / heat reports */
+    heat_columns,
+    /** Columns for live trading reports and logs */
+    live_columns,
+    /** Columns for partial-results / incremental reports */
+    partial_columns,
+    /** Columns for performance summary reports */
+    performance_columns,
+    /** Columns for risk-related reports */
+    risk_columns,
+    /** Columns for scheduled report output */
+    schedule_columns,
+    /** Walker: PnL summary columns */
+    walker_pnl_columns,
+    /** Walker: strategy-level summary columns */
+    walker_strategy_columns,
+};
+/**
+ * Immutable default columns mapping used across the application.
+ * Use `DEFAULT_COLUMNS` when you need a read-only reference to the
+ * canonical column configuration.
+ */
+const DEFAULT_COLUMNS = Object.freeze({ ...COLUMN_CONFIG });
+
 const { init, inject, provide } = diKit.createActivator("backtest");
 
 /**
@@ -221,6 +1296,7 @@ const validationServices$1 = {
     riskValidationService: Symbol('riskValidationService'),
     optimizerValidationService: Symbol('optimizerValidationService'),
     configValidationService: Symbol('configValidationService'),
+    columnValidationService: Symbol('columnValidationService'),
 };
 const templateServices$1 = {
     optimizerTemplateService: Symbol('optimizerTemplateService'),
@@ -1552,7 +2628,7 @@ const PersistScheduleAdapter = new PersistScheduleUtils();
  * Utility class for managing partial profit/loss levels persistence.
  *
  * Features:
- * - Memoized storage instances per symbol
+ * - Memoized storage instances per symbol:strategyName
  * - Custom adapter support
  * - Atomic read/write operations for partial data
  * - Crash-safe partial state management
@@ -1562,23 +2638,25 @@ const PersistScheduleAdapter = new PersistScheduleUtils();
 class PersistPartialUtils {
     constructor() {
         this.PersistPartialFactory = PersistBase;
-        this.getPartialStorage = functoolsKit.memoize(([symbol]) => `${symbol}`, (symbol) => Reflect.construct(this.PersistPartialFactory, [
-            symbol,
+        this.getPartialStorage = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => Reflect.construct(this.PersistPartialFactory, [
+            `${symbol}_${strategyName}`,
             `./dump/data/partial/`,
         ]));
         /**
-         * Reads persisted partial data for a symbol.
+         * Reads persisted partial data for a symbol and strategy.
          *
          * Called by ClientPartial.waitForInit() to restore state.
          * Returns empty object if no partial data exists.
          *
          * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
          * @returns Promise resolving to partial data record
          */
-        this.readPartialData = async (symbol) => {
+        this.readPartialData = async (symbol, strategyName) => {
             backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_READ_DATA);
-            const isInitial = !this.getPartialStorage.has(symbol);
-            const stateStorage = this.getPartialStorage(symbol);
+            const key = `${symbol}:${strategyName}`;
+            const isInitial = !this.getPartialStorage.has(key);
+            const stateStorage = this.getPartialStorage(symbol, strategyName);
             await stateStorage.waitForInit(isInitial);
             const PARTIAL_STORAGE_KEY = "levels";
             if (await stateStorage.hasValue(PARTIAL_STORAGE_KEY)) {
@@ -1594,12 +2672,14 @@ class PersistPartialUtils {
          *
          * @param partialData - Record of signal IDs to partial data
          * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
          * @returns Promise that resolves when write is complete
          */
-        this.writePartialData = async (partialData, symbol) => {
+        this.writePartialData = async (partialData, symbol, strategyName) => {
             backtest$1.loggerService.info(PERSIST_PARTIAL_UTILS_METHOD_NAME_WRITE_DATA);
-            const isInitial = !this.getPartialStorage.has(symbol);
-            const stateStorage = this.getPartialStorage(symbol);
+            const key = `${symbol}:${strategyName}`;
+            const isInitial = !this.getPartialStorage.has(key);
+            const stateStorage = this.getPartialStorage(symbol, strategyName);
             await stateStorage.waitForInit(isInitial);
             const PARTIAL_STORAGE_KEY = "levels";
             await stateStorage.writeValue(PARTIAL_STORAGE_KEY, partialData);
@@ -1634,10 +2714,10 @@ class PersistPartialUtils {
  * PersistPartialAdapter.usePersistPartialAdapter(RedisPersist);
  *
  * // Read partial data
- * const partialData = await PersistPartialAdapter.readPartialData("BTCUSDT");
+ * const partialData = await PersistPartialAdapter.readPartialData("BTCUSDT", "my-strategy");
  *
  * // Write partial data
- * await PersistPartialAdapter.writePartialData(partialData, "BTCUSDT");
+ * await PersistPartialAdapter.writePartialData(partialData, "BTCUSDT", "my-strategy");
  * ```
  */
 const PersistPartialAdapter = new PersistPartialUtils();
@@ -1765,53 +2845,6 @@ var emitters = /*#__PURE__*/Object.freeze({
     walkerStopSubject: walkerStopSubject
 });
 
-/**
- * Converts markdown content to plain text with minimal formatting
- * @param content - Markdown string to convert
- * @returns Plain text representation
- */
-const toPlainString = (content) => {
-    if (!content) {
-        return "";
-    }
-    let text = content;
-    // Remove code blocks
-    text = text.replace(/```[\s\S]*?```/g, "");
-    text = text.replace(/`([^`]+)`/g, "$1");
-    // Remove images
-    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1");
-    // Convert links to text only (keep link text, remove URL)
-    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
-    // Remove headers (convert to plain text)
-    text = text.replace(/^#{1,6}\s+(.+)$/gm, "$1");
-    // Remove bold and italic markers
-    text = text.replace(/\*\*\*(.+?)\*\*\*/g, "$1");
-    text = text.replace(/\*\*(.+?)\*\*/g, "$1");
-    text = text.replace(/\*(.+?)\*/g, "$1");
-    text = text.replace(/___(.+?)___/g, "$1");
-    text = text.replace(/__(.+?)__/g, "$1");
-    text = text.replace(/_(.+?)_/g, "$1");
-    // Remove strikethrough
-    text = text.replace(/~~(.+?)~~/g, "$1");
-    // Convert lists to plain text with bullets
-    text = text.replace(/^\s*[-*+]\s+/gm, "• ");
-    text = text.replace(/^\s*\d+\.\s+/gm, "• ");
-    // Remove blockquotes
-    text = text.replace(/^\s*>\s+/gm, "");
-    // Remove horizontal rules
-    text = text.replace(/^(\*{3,}|-{3,}|_{3,})$/gm, "");
-    // Remove HTML tags
-    text = text.replace(/<[^>]+>/g, "");
-    // Remove excessive whitespace and normalize line breaks
-    text = text.replace(/\n[\s\n]*\n/g, "\n");
-    text = text.replace(/[ \t]+/g, " ");
-    // Remove all newline characters
-    text = text.replace(/\n/g, " ");
-    // Remove excessive spaces after newline removal
-    text = text.replace(/\s+/g, " ");
-    return text.trim();
-};
-
 const INTERVAL_MINUTES$1 = {
     "1m": 1,
     "3m": 3,
@@ -3390,7 +4423,7 @@ class RiskUtils {
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
-         * @returns Promise resolving to RiskStatistics object with counts and event list
+         * @returns Promise resolving to RiskStatisticsModel object with counts and event list
          *
          * @example
          * ```typescript
@@ -3437,6 +4470,7 @@ class RiskUtils {
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -3460,7 +4494,7 @@ class RiskUtils {
          * // - my-strategy: 1
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(RISK_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
@@ -3472,7 +4506,7 @@ class RiskUtils {
                     backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.riskMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.riskMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Generates and saves markdown report to file.
@@ -3489,6 +4523,7 @@ class RiskUtils {
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
          * @param path - Output directory path (default: "./dump/risk")
+         * @param columns - Optional columns configuration for the report
          * @returns Promise that resolves when file is written
          *
          * @example
@@ -3505,7 +4540,7 @@ class RiskUtils {
          * }
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(RISK_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
@@ -3518,7 +4553,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);
         };
     }
 }
@@ -3543,25 +4578,25 @@ const NOOP_RISK = {
     addSignal: () => Promise.resolve(),
     removeSignal: () => Promise.resolve(),
 };
-const GET_RISK_FN = (dto, self) => {
+const GET_RISK_FN = (dto, backtest, self) => {
     const hasRiskName = !!dto.riskName;
-    const hasRiskList = !!(dto.riskList?.length);
+    const hasRiskList = !!dto.riskList?.length;
     // Нет ни riskName, ни riskList
     if (!hasRiskName && !hasRiskList) {
         return NOOP_RISK;
     }
     // Есть только riskName (без riskList)
     if (hasRiskName && !hasRiskList) {
-        return self.riskConnectionService.getRisk(dto.riskName);
+        return self.riskConnectionService.getRisk(dto.riskName, backtest);
     }
     // Есть только riskList (без riskName)
     if (!hasRiskName && hasRiskList) {
-        return new MergeRisk(dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName)));
+        return new MergeRisk(dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName, backtest)));
     }
     // Есть и riskName, и riskList - объединяем (riskName в начало)
     return new MergeRisk([
-        self.riskConnectionService.getRisk(dto.riskName),
-        ...dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName))
+        self.riskConnectionService.getRisk(dto.riskName, backtest),
+        ...dto.riskList.map((riskName) => self.riskConnectionService.getRisk(riskName, backtest)),
     ]);
 };
 /**
@@ -3603,7 +4638,7 @@ class StrategyConnectionService {
          * @param strategyName - Name of registered strategy schema
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = functoolsKit.memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => {
+        this.getStrategy = functoolsKit.memoize(([symbol, strategyName, backtest]) => `${symbol}:${strategyName}:${backtest ? "backtest" : "live"}`, (symbol, strategyName, backtest) => {
             const { riskName = "", riskList = [], getSignal, interval, callbacks, } = this.strategySchemaService.get(strategyName);
             return new ClientStrategy({
                 symbol,
@@ -3616,7 +4651,7 @@ class StrategyConnectionService {
                 risk: GET_RISK_FN({
                     riskName,
                     riskList,
-                }, this),
+                }, backtest, this),
                 riskName,
                 strategyName,
                 getSignal,
@@ -3633,12 +4668,13 @@ class StrategyConnectionService {
          *
          * @returns Promise resolving to pending signal or null
          */
-        this.getPendingSignal = async (symbol, strategyName) => {
+        this.getPendingSignal = async (backtest, symbol, strategyName) => {
             this.loggerService.log("strategyConnectionService getPendingSignal", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const strategy = this.getStrategy(symbol, strategyName);
+            const strategy = this.getStrategy(symbol, strategyName, backtest);
             return await strategy.getPendingSignal(symbol, strategyName);
         };
         /**
@@ -3651,12 +4687,13 @@ class StrategyConnectionService {
          * @param strategyName - Name of the strategy
          * @returns Promise resolving to true if strategy is stopped, false otherwise
          */
-        this.getStopped = async (symbol, strategyName) => {
+        this.getStopped = async (backtest, symbol, strategyName) => {
             this.loggerService.log("strategyConnectionService getStopped", {
                 symbol,
                 strategyName,
+                backtest,
             });
-            const strategy = this.getStrategy(symbol, strategyName);
+            const strategy = this.getStrategy(symbol, strategyName, backtest);
             return await strategy.getStopped(symbol, strategyName);
         };
         /**
@@ -3674,7 +4711,8 @@ class StrategyConnectionService {
                 symbol,
                 strategyName,
             });
-            const strategy = this.getStrategy(symbol, strategyName);
+            const backtest = this.executionContextService.context.backtest;
+            const strategy = this.getStrategy(symbol, strategyName, backtest);
             await strategy.waitForInit();
             const tick = await strategy.tick(symbol, strategyName);
             {
@@ -3705,7 +4743,8 @@ class StrategyConnectionService {
                 strategyName,
                 candleCount: candles.length,
             });
-            const strategy = this.getStrategy(symbol, strategyName);
+            const backtest = this.executionContextService.context.backtest;
+            const strategy = this.getStrategy(symbol, strategyName, backtest);
             await strategy.waitForInit();
             const tick = await strategy.backtest(symbol, strategyName, candles);
             {
@@ -3726,11 +4765,11 @@ class StrategyConnectionService {
          * @param strategyName - Name of strategy to stop
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (ctx, backtest) => {
+        this.stop = async (backtest, ctx) => {
             this.loggerService.log("strategyConnectionService stop", {
                 ctx,
             });
-            const strategy = this.getStrategy(ctx.symbol, ctx.strategyName);
+            const strategy = this.getStrategy(ctx.symbol, ctx.strategyName, backtest);
             await strategy.stop(ctx.symbol, ctx.strategyName, backtest);
         };
         /**
@@ -3741,12 +4780,12 @@ class StrategyConnectionService {
          *
          * @param ctx - Optional context with symbol and strategyName (clears all if not provided)
          */
-        this.clear = async (ctx) => {
+        this.clear = async (backtest, ctx) => {
             this.loggerService.log("strategyConnectionService clear", {
                 ctx,
             });
             if (ctx) {
-                const key = `${ctx.symbol}:${ctx.strategyName}`;
+                const key = `${ctx.symbol}:${ctx.strategyName}:${backtest ? "backtest" : "live"}`;
                 this.getStrategy.clear(key);
             }
             else {
@@ -4141,9 +5180,15 @@ const DO_VALIDATION_FN = functoolsKit.trycatch(async (validation, params) => {
  * Initializes active positions by reading from persistence.
  * Uses singleshot pattern to ensure it only runs once.
  * This function is exported for use in tests or other modules.
+ *
+ * In backtest mode, initializes with empty Map. In live mode, reads from persist storage.
  */
 const WAIT_FOR_INIT_FN$1 = async (self) => {
-    self.params.logger.debug("ClientRisk waitForInit");
+    self.params.logger.debug("ClientRisk waitForInit", { backtest: self.params.backtest });
+    if (self.params.backtest) {
+        self._activePositions = new Map();
+        return;
+    }
     const persistedPositions = await PersistRiskAdapter.readPositionData(self.params.riskName);
     self._activePositions = new Map(persistedPositions);
 };
@@ -4191,6 +5236,7 @@ class ClientRisk {
             this.params.logger.debug("ClientRisk checkSignal", {
                 symbol: params.symbol,
                 strategyName: params.strategyName,
+                backtest: this.params.backtest,
             });
             if (this._activePositions === POSITION_NEED_FETCH) {
                 await this.waitForInit();
@@ -4236,8 +5282,12 @@ class ClientRisk {
     }
     /**
      * Persists current active positions to disk.
+     * Skips in backtest mode.
      */
     async _updatePositions() {
+        if (this.params.backtest) {
+            return;
+        }
         if (this._activePositions === POSITION_NEED_FETCH) {
             await this.waitForInit();
         }
@@ -4251,6 +5301,7 @@ class ClientRisk {
         this.params.logger.debug("ClientRisk addSignal", {
             symbol,
             context,
+            backtest: this.params.backtest,
         });
         if (this._activePositions === POSITION_NEED_FETCH) {
             await this.waitForInit();
@@ -4273,6 +5324,7 @@ class ClientRisk {
         this.params.logger.debug("ClientRisk removeSignal", {
             symbol,
             context,
+            backtest: this.params.backtest,
         });
         if (this._activePositions === POSITION_NEED_FETCH) {
             await this.waitForInit();
@@ -4343,19 +5395,21 @@ class RiskConnectionService {
         this.loggerService = inject(TYPES.loggerService);
         this.riskSchemaService = inject(TYPES.riskSchemaService);
         /**
-         * Retrieves memoized ClientRisk instance for given risk name.
+         * Retrieves memoized ClientRisk instance for given risk name and backtest mode.
          *
          * Creates ClientRisk on first call, returns cached instance on subsequent calls.
-         * Cache key is riskName string.
+         * Cache key is "riskName:backtest" string to separate live and backtest instances.
          *
          * @param riskName - Name of registered risk schema
+         * @param backtest - True if backtest mode, false if live mode
          * @returns Configured ClientRisk instance
          */
-        this.getRisk = functoolsKit.memoize(([riskName]) => `${riskName}`, (riskName) => {
+        this.getRisk = functoolsKit.memoize(([riskName, backtest]) => `${riskName}:${backtest ? "backtest" : "live"}`, (riskName, backtest) => {
             const schema = this.riskSchemaService.get(riskName);
             return new ClientRisk({
                 ...schema,
                 logger: this.loggerService,
+                backtest,
                 onRejected: COMMIT_REJECTION_FN,
             });
         });
@@ -4367,7 +5421,7 @@ class RiskConnectionService {
          * ClientRisk will emit riskSubject event via onRejected callback when signal is rejected.
          *
          * @param params - Risk check arguments (portfolio state, position details)
-         * @param context - Execution context with risk name
+         * @param context - Execution context with risk name and backtest mode
          * @returns Promise resolving to risk check result
          */
         this.checkSignal = async (params, context) => {
@@ -4375,46 +5429,48 @@ class RiskConnectionService {
                 symbol: params.symbol,
                 context,
             });
-            return await this.getRisk(context.riskName).checkSignal(params);
+            return await this.getRisk(context.riskName, context.backtest).checkSignal(params);
         };
         /**
          * Registers an opened signal with the risk management system.
          * Routes to appropriate ClientRisk instance.
          *
          * @param symbol - Trading pair symbol
-         * @param context - Context information (strategyName, riskName)
+         * @param context - Context information (strategyName, riskName, backtest)
          */
         this.addSignal = async (symbol, context) => {
             this.loggerService.log("riskConnectionService addSignal", {
                 symbol,
                 context,
             });
-            await this.getRisk(context.riskName).addSignal(symbol, context);
+            await this.getRisk(context.riskName, context.backtest).addSignal(symbol, context);
         };
         /**
          * Removes a closed signal from the risk management system.
          * Routes to appropriate ClientRisk instance.
          *
          * @param symbol - Trading pair symbol
-         * @param context - Context information (strategyName, riskName)
+         * @param context - Context information (strategyName, riskName, backtest)
          */
         this.removeSignal = async (symbol, context) => {
             this.loggerService.log("riskConnectionService removeSignal", {
                 symbol,
                 context,
             });
-            await this.getRisk(context.riskName).removeSignal(symbol, context);
+            await this.getRisk(context.riskName, context.backtest).removeSignal(symbol, context);
         };
         /**
          * Clears the cached ClientRisk instance for the given risk name.
          *
          * @param riskName - Name of the risk schema to clear from cache
          */
-        this.clear = async (riskName) => {
+        this.clear = async (backtest, riskName) => {
             this.loggerService.log("riskConnectionService clear", {
                 riskName,
+                backtest,
             });
-            this.getRisk.clear(riskName);
+            const key = `${riskName}:${backtest ? "backtest" : "live"}`;
+            this.getRisk.clear(key);
         };
     }
 }
@@ -4637,7 +5693,7 @@ class StrategyCoreService {
          * @param strategyName - Name of the strategy
          * @returns Promise resolving to pending signal or null
          */
-        this.getPendingSignal = async (symbol, strategyName) => {
+        this.getPendingSignal = async (backtest, symbol, strategyName) => {
             this.loggerService.log("strategyCoreService getPendingSignal", {
                 symbol,
                 strategyName,
@@ -4646,7 +5702,7 @@ class StrategyCoreService {
                 throw new Error("strategyCoreService getPendingSignal requires a method context");
             }
             await this.validate(symbol, strategyName);
-            return await this.strategyConnectionService.getPendingSignal(symbol, strategyName);
+            return await this.strategyConnectionService.getPendingSignal(backtest, symbol, strategyName);
         };
         /**
          * Checks if the strategy has been stopped.
@@ -4658,16 +5714,17 @@ class StrategyCoreService {
          * @param strategyName - Name of the strategy
          * @returns Promise resolving to true if strategy is stopped, false otherwise
          */
-        this.getStopped = async (symbol, strategyName) => {
+        this.getStopped = async (backtest, symbol, strategyName) => {
             this.loggerService.log("strategyCoreService getStopped", {
                 symbol,
                 strategyName,
+                backtest,
             });
             if (!MethodContextService.hasContext()) {
                 throw new Error("strategyCoreService getStopped requires a method context");
             }
             await this.validate(symbol, strategyName);
-            return await this.strategyConnectionService.getStopped(symbol, strategyName);
+            return await this.strategyConnectionService.getStopped(backtest, symbol, strategyName);
         };
         /**
          * Checks signal status at a specific timestamp.
@@ -4741,13 +5798,13 @@ class StrategyCoreService {
          * @param strategyName - Name of strategy to stop
          * @returns Promise that resolves when stop flag is set
          */
-        this.stop = async (ctx, backtest) => {
+        this.stop = async (backtest, ctx) => {
             this.loggerService.log("strategyCoreService stop", {
                 ctx,
                 backtest,
             });
             await this.validate(ctx.symbol, ctx.strategyName);
-            return await this.strategyConnectionService.stop(ctx, backtest);
+            return await this.strategyConnectionService.stop(backtest, ctx);
         };
         /**
          * Clears the memoized ClientStrategy instance from cache.
@@ -4757,14 +5814,14 @@ class StrategyCoreService {
          *
          * @param ctx - Optional context with symbol and strategyName (clears all if not provided)
          */
-        this.clear = async (ctx) => {
+        this.clear = async (backtest, ctx) => {
             this.loggerService.log("strategyCoreService clear", {
                 ctx,
             });
             if (ctx) {
                 await this.validate(ctx.symbol, ctx.strategyName);
             }
-            return await this.strategyConnectionService.clear(ctx);
+            return await this.strategyConnectionService.clear(backtest, ctx);
         };
     }
 }
@@ -4905,14 +5962,15 @@ class RiskGlobalService {
          * If no riskName is provided, clears all risk data.
          * @param riskName - Optional name of the risk instance to clear
          */
-        this.clear = async (riskName) => {
+        this.clear = async (backtest, riskName) => {
             this.loggerService.log("riskGlobalService clear", {
                 riskName,
+                backtest,
             });
             if (riskName) {
                 await this.validate(riskName);
             }
-            return await this.riskConnectionService.clear(riskName);
+            return await this.riskConnectionService.clear(backtest, riskName);
         };
     }
 }
@@ -5035,6 +6093,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}`);
             }
@@ -5443,7 +6514,7 @@ class BacktestLogicPrivateService {
                 });
             }
             // Check if strategy should stop before processing next frame
-            if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+            if (await this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName)) {
                 this.loggerService.info("backtestLogicPrivateService stopped by user request (before tick)", {
                     symbol,
                     when: when.toISOString(),
@@ -5468,7 +6539,7 @@ class BacktestLogicPrivateService {
                 continue;
             }
             // Check if strategy should stop when idle (no active signal)
-            if (await functoolsKit.and(Promise.resolve(result.action === "idle"), this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+            if (await functoolsKit.and(Promise.resolve(result.action === "idle"), this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName))) {
                 this.loggerService.info("backtestLogicPrivateService stopped by user request (idle state)", {
                     symbol,
                     when: when.toISOString(),
@@ -5570,7 +6641,7 @@ class BacktestLogicPrivateService {
                 }
                 yield backtestResult;
                 // Check if strategy should stop after signal is closed
-                if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName)) {
                     this.loggerService.info("backtestLogicPrivateService stopped by user request (after scheduled signal closed)", {
                         symbol,
                         signalId: backtestResult.signal.id,
@@ -5663,7 +6734,7 @@ class BacktestLogicPrivateService {
                 }
                 yield backtestResult;
                 // Check if strategy should stop after signal is closed
-                if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(true, symbol, this.methodContextService.context.strategyName)) {
                     this.loggerService.info("backtestLogicPrivateService stopped by user request (after signal closed)", {
                         symbol,
                         signalId: backtestResult.signal.id,
@@ -5806,7 +6877,7 @@ class LiveLogicPrivateService {
             previousEventTimestamp = currentTimestamp;
             // Check if strategy should stop when idle (no active signal)
             if (result.action === "idle") {
-                if (await functoolsKit.and(Promise.resolve(true), this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+                if (await functoolsKit.and(Promise.resolve(true), this.strategyCoreService.getStopped(false, symbol, this.methodContextService.context.strategyName))) {
                     this.loggerService.info("liveLogicPrivateService stopped by user request (idle state)", {
                         symbol,
                         when: when.toISOString(),
@@ -5828,7 +6899,7 @@ class LiveLogicPrivateService {
             yield result;
             // Check if strategy should stop after signal is closed
             if (result.action === "closed") {
-                if (await this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName)) {
+                if (await this.strategyCoreService.getStopped(false, symbol, this.methodContextService.context.strategyName)) {
                     this.loggerService.info("liveLogicPrivateService stopped by user request (after signal closed)", {
                         symbol,
                         signalId: result.signal.id,
@@ -6276,167 +7347,80 @@ class BacktestCommandService {
             }
             {
                 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,
-    },
-];
+                riskName && this.riskValidationService.validate(riskName, METHOD_NAME_RUN$1);
+                riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_RUN$1));
+            }
+            return this.backtestLogicPublicService.run(symbol, context);
+        };
+    }
+}
+
+const METHOD_NAME_RUN = "walkerCommandService run";
+/**
+ * Global service providing access to walker functionality.
+ *
+ * Simple wrapper around WalkerLogicPublicService for dependency injection.
+ * Used by public API exports.
+ */
+class WalkerCommandService {
+    constructor() {
+        this.loggerService = inject(TYPES.loggerService);
+        this.walkerLogicPublicService = inject(TYPES.walkerLogicPublicService);
+        this.walkerSchemaService = inject(TYPES.walkerSchemaService);
+        this.strategyValidationService = inject(TYPES.strategyValidationService);
+        this.exchangeValidationService = inject(TYPES.exchangeValidationService);
+        this.frameValidationService = inject(TYPES.frameValidationService);
+        this.walkerValidationService = inject(TYPES.walkerValidationService);
+        this.strategySchemaService = inject(TYPES.strategySchemaService);
+        this.riskValidationService = inject(TYPES.riskValidationService);
+        /**
+         * Runs walker comparison for a symbol with context propagation.
+         *
+         * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
+         * @param context - Walker context with strategies and metric
+         */
+        this.run = (symbol, context) => {
+            this.loggerService.log(METHOD_NAME_RUN, {
+                symbol,
+                context,
+            });
+            {
+                this.exchangeValidationService.validate(context.exchangeName, METHOD_NAME_RUN);
+                this.frameValidationService.validate(context.frameName, METHOD_NAME_RUN);
+                this.walkerValidationService.validate(context.walkerName, METHOD_NAME_RUN);
+            }
+            {
+                const walkerSchema = this.walkerSchemaService.get(context.walkerName);
+                for (const strategyName of walkerSchema.strategies) {
+                    const { riskName, riskList } = this.strategySchemaService.get(strategyName);
+                    this.strategyValidationService.validate(strategyName, METHOD_NAME_RUN);
+                    riskName && this.riskValidationService.validate(riskName, METHOD_NAME_RUN);
+                    riskList && riskList.forEach((riskName) => this.riskValidationService.validate(riskName, METHOD_NAME_RUN));
+                }
+            }
+            return this.walkerLogicPublicService.run(symbol, context);
+        };
+    }
+}
+
+/**
+ * Checks if a value is unsafe for display (not a number, NaN, or Infinity).
+ *
+ * @param value - Value to check
+ * @returns true if value is unsafe, false otherwise
+ */
+function isUnsafe$3(value) {
+    if (typeof value !== "number") {
+        return true;
+    }
+    if (isNaN(value)) {
+        return true;
+    }
+    if (!isFinite(value)) {
+        return true;
+    }
+    return false;
+}
 /** Maximum number of signals to store in backtest reports */
 const MAX_EVENTS$6 = 250;
 /**
@@ -6530,9 +7514,10 @@ let ReportStorage$5 = class ReportStorage {
      * Generates markdown report with all closed signals for a strategy (View).
      *
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all signals
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.backtest_columns) {
         const stats = await this.getData();
         if (stats.totalSignals === 0) {
             return [
@@ -6541,10 +7526,15 @@ let ReportStorage$5 = class ReportStorage {
                 "No signals closed yet."
             ].join("\n");
         }
-        const visibleColumns = columns$6.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._signalList.map((closedSignal) => visibleColumns.map((col) => col.format(closedSignal)));
+        const rows = await Promise.all(this._signalList.map(async (closedSignal, index) => Promise.all(visibleColumns.map((col) => col.format(closedSignal, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map(row => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -6569,9 +7559,10 @@ let ReportStorage$5 = class ReportStorage {
      *
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/backtest")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/backtest") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path$1 = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -6679,6 +7670,7 @@ class BacktestMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all closed signals
          *
          * @example
@@ -6688,13 +7680,13 @@ class BacktestMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.backtest_columns) => {
             this.loggerService.log("backtestMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -6704,6 +7696,7 @@ class BacktestMarkdownService {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/backtest")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -6716,14 +7709,14 @@ class BacktestMarkdownService {
          * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/backtest") => {
+        this.dump = async (symbol, strategyName, path = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) => {
             this.loggerService.log("backtestMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(strategyName, path);
+            await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated signal data from storage.
@@ -6791,104 +7784,6 @@ function isUnsafe$2(value) {
     }
     return false;
 }
-const columns$5 = [
-    {
-        key: "timestamp",
-        label: "Timestamp",
-        format: (data) => new Date(data.timestamp).toISOString(),
-        isVisible: () => true,
-    },
-    {
-        key: "action",
-        label: "Action",
-        format: (data) => data.action.toUpperCase(),
-        isVisible: () => true,
-    },
-    {
-        key: "symbol",
-        label: "Symbol",
-        format: (data) => data.symbol ?? "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "signalId",
-        label: "Signal ID",
-        format: (data) => data.signalId ?? "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "position",
-        label: "Position",
-        format: (data) => data.position?.toUpperCase() ?? "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "note",
-        label: "Note",
-        format: (data) => toPlainString(data.note ?? "N/A"),
-        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
-    },
-    {
-        key: "currentPrice",
-        label: "Current Price",
-        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
-        isVisible: () => true,
-    },
-    {
-        key: "openPrice",
-        label: "Open Price",
-        format: (data) => data.openPrice !== undefined ? `${data.openPrice.toFixed(8)} USD` : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "takeProfit",
-        label: "Take Profit",
-        format: (data) => data.takeProfit !== undefined
-            ? `${data.takeProfit.toFixed(8)} USD`
-            : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "stopLoss",
-        label: "Stop Loss",
-        format: (data) => data.stopLoss !== undefined ? `${data.stopLoss.toFixed(8)} USD` : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "percentTp",
-        label: "% to TP",
-        format: (data) => data.percentTp !== undefined ? `${data.percentTp.toFixed(2)}%` : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "percentSl",
-        label: "% to SL",
-        format: (data) => data.percentSl !== undefined ? `${data.percentSl.toFixed(2)}%` : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "pnl",
-        label: "PNL (net)",
-        format: (data) => {
-            if (data.pnl === undefined)
-                return "N/A";
-            return `${data.pnl > 0 ? "+" : ""}${data.pnl.toFixed(2)}%`;
-        },
-        isVisible: () => true,
-    },
-    {
-        key: "closeReason",
-        label: "Close Reason",
-        format: (data) => data.closeReason ?? "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "duration",
-        label: "Duration (min)",
-        format: (data) => data.duration !== undefined ? `${data.duration}` : "N/A",
-        isVisible: () => true,
-    },
-];
 /** Maximum number of events to store in live trading reports */
 const MAX_EVENTS$5 = 250;
 /**
@@ -7100,9 +7995,10 @@ let ReportStorage$4 = class ReportStorage {
      * Generates markdown report with all tick events for a strategy (View).
      *
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all events
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.live_columns) {
         const stats = await this.getData();
         if (stats.totalEvents === 0) {
             return [
@@ -7111,10 +8007,15 @@ let ReportStorage$4 = class ReportStorage {
                 "No events recorded yet."
             ].join("\n");
         }
-        const visibleColumns = columns$5.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
+        const rows = await Promise.all(this._eventList.map(async (event, index) => Promise.all(visibleColumns.map((col) => col.format(event, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map(row => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -7139,9 +8040,10 @@ let ReportStorage$4 = class ReportStorage {
      *
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/live")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/live") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path$1 = "./dump/live", columns = COLUMN_CONFIG.live_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -7262,6 +8164,7 @@ class LiveMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
@@ -7271,13 +8174,13 @@ class LiveMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.live_columns) => {
             this.loggerService.log("liveMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -7287,6 +8190,7 @@ class LiveMarkdownService {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/live")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -7299,14 +8203,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.
@@ -7342,88 +8246,20 @@ class LiveMarkdownService {
          * Initializes the service by subscribing to live signal events.
          * Uses singleshot to ensure initialization happens only once.
          * Automatically called on first use.
-         *
-         * @example
-         * ```typescript
-         * const service = new LiveMarkdownService();
-         * await service.init(); // Subscribe to live events
-         * ```
-         */
-        this.init = functoolsKit.singleshot(async () => {
-            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,
-    },
-];
+         *
+         * @example
+         * ```typescript
+         * const service = new LiveMarkdownService();
+         * await service.init(); // Subscribe to live events
+         * ```
+         */
+        this.init = functoolsKit.singleshot(async () => {
+            this.loggerService.log("liveMarkdownService init");
+            signalLiveEmitter.subscribe(this.tick);
+        });
+    }
+}
+
 /** Maximum number of events to store in schedule reports */
 const MAX_EVENTS$4 = 250;
 /**
@@ -7568,9 +8404,10 @@ let ReportStorage$3 = class ReportStorage {
      * Generates markdown report with all scheduled events for a strategy (View).
      *
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all events
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.schedule_columns) {
         const stats = await this.getData();
         if (stats.totalEvents === 0) {
             return [
@@ -7579,10 +8416,15 @@ let ReportStorage$3 = class ReportStorage {
                 "No scheduled signals recorded yet."
             ].join("\n");
         }
-        const visibleColumns = columns$4.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
+        const rows = await Promise.all(this._eventList.map(async (event, index) => Promise.all(visibleColumns.map((col) => col.format(event, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -7605,9 +8447,10 @@ let ReportStorage$3 = class ReportStorage {
      *
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/schedule")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/schedule") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path$1 = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -7713,6 +8556,7 @@ class ScheduleMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
@@ -7722,13 +8566,13 @@ class ScheduleMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.schedule_columns) => {
             this.loggerService.log("scheduleMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -7738,6 +8582,7 @@ class ScheduleMarkdownService {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/schedule")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -7750,14 +8595,14 @@ class ScheduleMarkdownService {
          * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/schedule") => {
+        this.dump = async (symbol, strategyName, path = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) => {
             this.loggerService.log("scheduleMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(strategyName, path);
+            await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
@@ -7816,86 +8661,6 @@ function percentile(sortedArray, p) {
     const index = Math.ceil((sortedArray.length * p) / 100) - 1;
     return sortedArray[Math.max(0, index)];
 }
-const columns$3 = [
-    {
-        key: "metricType",
-        label: "Metric Type",
-        format: (data) => data.metricType,
-        isVisible: () => true,
-    },
-    {
-        key: "count",
-        label: "Count",
-        format: (data) => data.count.toString(),
-        isVisible: () => true,
-    },
-    {
-        key: "totalDuration",
-        label: "Total (ms)",
-        format: (data) => data.totalDuration.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "avgDuration",
-        label: "Avg (ms)",
-        format: (data) => data.avgDuration.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "minDuration",
-        label: "Min (ms)",
-        format: (data) => data.minDuration.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "maxDuration",
-        label: "Max (ms)",
-        format: (data) => data.maxDuration.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "stdDev",
-        label: "Std Dev (ms)",
-        format: (data) => data.stdDev.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "median",
-        label: "Median (ms)",
-        format: (data) => data.median.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "p95",
-        label: "P95 (ms)",
-        format: (data) => data.p95.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "p99",
-        label: "P99 (ms)",
-        format: (data) => data.p99.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "avgWaitTime",
-        label: "Avg Wait (ms)",
-        format: (data) => data.avgWaitTime.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "minWaitTime",
-        label: "Min Wait (ms)",
-        format: (data) => data.minWaitTime.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "maxWaitTime",
-        label: "Max Wait (ms)",
-        format: (data) => data.maxWaitTime.toFixed(2),
-        isVisible: () => true,
-    },
-];
 /** Maximum number of performance events to store per strategy */
 const MAX_EVENTS$3 = 10000;
 /**
@@ -7998,9 +8763,10 @@ class PerformanceStorage {
      * Generates markdown report with performance statistics.
      *
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.performance_columns) {
         const stats = await this.getData(strategyName);
         if (stats.totalEvents === 0) {
             return [
@@ -8012,10 +8778,15 @@ class PerformanceStorage {
         // Sort metrics by total duration (descending) to show bottlenecks first
         const sortedMetrics = Object.values(stats.metricStats).sort((a, b) => b.totalDuration - a.totalDuration);
         // Generate summary table using Column interface
-        const visibleColumns = columns$3.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = sortedMetrics.map((metric) => visibleColumns.map((col) => col.format(metric)));
+        const rows = await Promise.all(sortedMetrics.map(async (metric, index) => Promise.all(visibleColumns.map((col) => col.format(metric, index)))));
         const tableData = [header, separator, ...rows];
         const summaryTable = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         // Calculate percentage of total time for each metric
@@ -8046,9 +8817,10 @@ class PerformanceStorage {
      *
      * @param strategyName - Strategy name
      * @param path - Directory path to save report
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/performance") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path$1 = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -8141,6 +8913,7 @@ class PerformanceMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string
          *
          * @example
@@ -8149,13 +8922,13 @@ class PerformanceMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.performance_columns) => {
             this.loggerService.log("performanceMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves performance report to disk.
@@ -8163,6 +8936,7 @@ class PerformanceMarkdownService {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -8173,14 +8947,14 @@ class PerformanceMarkdownService {
          * await performanceService.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/performance") => {
+        this.dump = async (symbol, strategyName, path = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) => {
             this.loggerService.log("performanceMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(strategyName, path);
+            await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated performance data from storage.
@@ -8239,135 +9013,6 @@ function formatMetric(value) {
     }
     return value.toFixed(2);
 }
-/**
- * Creates strategy comparison columns based on metric name.
- * Dynamically builds column configuration with metric-specific header.
- *
- * @param metric - Metric being optimized
- * @returns Array of column configurations for strategy comparison table
- */
-function createStrategyColumns(metric) {
-    return [
-        {
-            key: "rank",
-            label: "Rank",
-            format: (data, index) => `${index + 1}`,
-            isVisible: () => true,
-        },
-        {
-            key: "strategy",
-            label: "Strategy",
-            format: (data) => data.strategyName,
-            isVisible: () => true,
-        },
-        {
-            key: "metric",
-            label: metric,
-            format: (data) => formatMetric(data.metricValue),
-            isVisible: () => true,
-        },
-        {
-            key: "totalSignals",
-            label: "Total Signals",
-            format: (data) => `${data.stats.totalSignals}`,
-            isVisible: () => true,
-        },
-        {
-            key: "winRate",
-            label: "Win Rate",
-            format: (data) => data.stats.winRate !== null
-                ? `${data.stats.winRate.toFixed(2)}%`
-                : "N/A",
-            isVisible: () => true,
-        },
-        {
-            key: "avgPnl",
-            label: "Avg PNL",
-            format: (data) => data.stats.avgPnl !== null
-                ? `${data.stats.avgPnl > 0 ? "+" : ""}${data.stats.avgPnl.toFixed(2)}%`
-                : "N/A",
-            isVisible: () => true,
-        },
-        {
-            key: "totalPnl",
-            label: "Total PNL",
-            format: (data) => data.stats.totalPnl !== null
-                ? `${data.stats.totalPnl > 0 ? "+" : ""}${data.stats.totalPnl.toFixed(2)}%`
-                : "N/A",
-            isVisible: () => true,
-        },
-        {
-            key: "sharpeRatio",
-            label: "Sharpe Ratio",
-            format: (data) => data.stats.sharpeRatio !== null
-                ? `${data.stats.sharpeRatio.toFixed(3)}`
-                : "N/A",
-            isVisible: () => true,
-        },
-        {
-            key: "stdDev",
-            label: "Std Dev",
-            format: (data) => data.stats.stdDev !== null
-                ? `${data.stats.stdDev.toFixed(3)}%`
-                : "N/A",
-            isVisible: () => true,
-        },
-    ];
-}
-/**
- * Column configuration for PNL table.
- * Defines all columns for displaying closed signals across strategies.
- */
-const pnlColumns = [
-    {
-        key: "strategy",
-        label: "Strategy",
-        format: (data) => data.strategyName,
-        isVisible: () => true,
-    },
-    {
-        key: "signalId",
-        label: "Signal ID",
-        format: (data) => data.signalId,
-        isVisible: () => true,
-    },
-    {
-        key: "symbol",
-        label: "Symbol",
-        format: (data) => data.symbol,
-        isVisible: () => true,
-    },
-    {
-        key: "position",
-        label: "Position",
-        format: (data) => data.position.toUpperCase(),
-        isVisible: () => true,
-    },
-    {
-        key: "pnl",
-        label: "PNL (net)",
-        format: (data) => `${data.pnl > 0 ? "+" : ""}${data.pnl.toFixed(2)}%`,
-        isVisible: () => true,
-    },
-    {
-        key: "closeReason",
-        label: "Close Reason",
-        format: (data) => data.closeReason,
-        isVisible: () => true,
-    },
-    {
-        key: "openTime",
-        label: "Open Time",
-        format: (data) => new Date(data.openTime).toISOString(),
-        isVisible: () => true,
-    },
-    {
-        key: "closeTime",
-        label: "Close Time",
-        format: (data) => new Date(data.closeTime).toISOString(),
-        isVisible: () => true,
-    },
-];
 /**
  * Storage class for accumulating walker results.
  * Maintains a list of all strategy results and provides methods to generate reports.
@@ -8399,7 +9044,7 @@ let ReportStorage$2 = class ReportStorage {
         this._strategyResults.unshift({
             strategyName: data.strategyName,
             stats: data.stats,
-            metricValue: data.metricValue,
+            metricValue: isUnsafe$1(data.metricValue) ? null : data.metricValue,
         });
     }
     /**
@@ -8432,11 +9077,11 @@ let ReportStorage$2 = class ReportStorage {
      * Generates comparison table for top N strategies (View).
      * Sorts strategies by metric value and formats as markdown table.
      *
-     * @param metric - Metric being optimized
      * @param topN - Number of top strategies to include (default: 10)
+     * @param columns - Column configuration for formatting the strategy comparison table
      * @returns Markdown formatted comparison table
      */
-    getComparisonTable(metric, topN = 10) {
+    async getComparisonTable(topN = 10, columns = COLUMN_CONFIG.walker_strategy_columns) {
         if (this._strategyResults.length === 0) {
             return "No strategy results available.";
         }
@@ -8449,13 +9094,17 @@ let ReportStorage$2 = class ReportStorage {
         // Take top N strategies
         const topStrategies = sortedResults.slice(0, topN);
         // Get columns configuration
-        const columns = createStrategyColumns(metric);
-        const visibleColumns = columns.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         // Build table header
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
         // Build table rows
-        const rows = topStrategies.map((result, index) => visibleColumns.map((col) => col.format(result, index)));
+        const rows = await Promise.all(topStrategies.map(async (result, index) => Promise.all(visibleColumns.map((col) => col.format(result, index)))));
         const tableData = [header, separator, ...rows];
         return tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
     }
@@ -8463,9 +9112,10 @@ let ReportStorage$2 = class ReportStorage {
      * Generates PNL table showing all closed signals across all strategies (View).
      * Collects all signals from all strategies and formats as markdown table.
      *
+     * @param columns - Column configuration for formatting the PNL table
      * @returns Markdown formatted PNL table
      */
-    getPnlTable() {
+    async getPnlTable(columns = COLUMN_CONFIG.walker_pnl_columns) {
         if (this._strategyResults.length === 0) {
             return "No strategy results available.";
         }
@@ -8489,11 +9139,16 @@ let ReportStorage$2 = class ReportStorage {
             return "No closed signals available.";
         }
         // Build table header
-        const visibleColumns = pnlColumns.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
         // Build table rows
-        const rows = allSignals.map((signal) => visibleColumns.map((col) => col.format(signal)));
+        const rows = await Promise.all(allSignals.map(async (signal, index) => Promise.all(visibleColumns.map((col) => col.format(signal, index)))));
         const tableData = [header, separator, ...rows];
         return tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
     }
@@ -8504,9 +9159,11 @@ let ReportStorage$2 = class ReportStorage {
      * @param symbol - Trading symbol
      * @param metric - Metric being optimized
      * @param context - Context with exchangeName and frameName
+     * @param strategyColumns - Column configuration for strategy comparison table
+     * @param pnlColumns - Column configuration for PNL table
      * @returns Markdown formatted report with all results
      */
-    async getReport(symbol, metric, context) {
+    async getReport(symbol, metric, context, strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) {
         const results = await this.getData(symbol, metric, context);
         // Get total signals for best strategy
         const bestStrategySignals = results.bestStats?.totalSignals ?? 0;
@@ -8526,11 +9183,11 @@ let ReportStorage$2 = class ReportStorage {
             "",
             "## Top Strategies Comparison",
             "",
-            this.getComparisonTable(metric, 10),
+            await this.getComparisonTable(10, strategyColumns),
             "",
             "## All Signals (PNL Table)",
             "",
-            this.getPnlTable(),
+            await this.getPnlTable(pnlColumns),
             "",
             "**Note:** Higher values are better for all metrics except Standard Deviation (lower is better)."
         ].join("\n");
@@ -8542,9 +9199,11 @@ let ReportStorage$2 = class ReportStorage {
      * @param metric - Metric being optimized
      * @param context - Context with exchangeName and frameName
      * @param path - Directory path to save report (default: "./dump/walker")
+     * @param strategyColumns - Column configuration for strategy comparison table
+     * @param pnlColumns - Column configuration for PNL table
      */
-    async dump(symbol, metric, context, path$1 = "./dump/walker") {
-        const markdown = await this.getReport(symbol, metric, context);
+    async dump(symbol, metric, context, path$1 = "./dump/walker", strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) {
+        const markdown = await this.getReport(symbol, metric, context, strategyColumns, pnlColumns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -8637,6 +9296,8 @@ class WalkerMarkdownService {
          * @param symbol - Trading symbol
          * @param metric - Metric being optimized
          * @param context - Context with exchangeName and frameName
+         * @param strategyColumns - Column configuration for strategy comparison table
+         * @param pnlColumns - Column configuration for PNL table
          * @returns Markdown formatted report string
          *
          * @example
@@ -8646,7 +9307,7 @@ class WalkerMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (walkerName, symbol, metric, context) => {
+        this.getReport = async (walkerName, symbol, metric, context, strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) => {
             this.loggerService.log("walkerMarkdownService getReport", {
                 walkerName,
                 symbol,
@@ -8654,7 +9315,7 @@ class WalkerMarkdownService {
                 context,
             });
             const storage = this.getStorage(walkerName);
-            return storage.getReport(symbol, metric, context);
+            return storage.getReport(symbol, metric, context, strategyColumns, pnlColumns);
         };
         /**
          * Saves walker report to disk.
@@ -8666,6 +9327,8 @@ class WalkerMarkdownService {
          * @param metric - Metric being optimized
          * @param context - Context with exchangeName and frameName
          * @param path - Directory path to save report (default: "./dump/walker")
+         * @param strategyColumns - Column configuration for strategy comparison table
+         * @param pnlColumns - Column configuration for PNL table
          *
          * @example
          * ```typescript
@@ -8678,7 +9341,7 @@ class WalkerMarkdownService {
          * await service.dump("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" }, "./custom/path");
          * ```
          */
-        this.dump = async (walkerName, symbol, metric, context, path = "./dump/walker") => {
+        this.dump = async (walkerName, symbol, metric, context, path = "./dump/walker", strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) => {
             this.loggerService.log("walkerMarkdownService dump", {
                 walkerName,
                 symbol,
@@ -8687,7 +9350,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.
@@ -8753,80 +9416,6 @@ function isUnsafe(value) {
     }
     return false;
 }
-const columns$2 = [
-    {
-        key: "symbol",
-        label: "Symbol",
-        format: (data) => data.symbol,
-        isVisible: () => true,
-    },
-    {
-        key: "totalPnl",
-        label: "Total PNL",
-        format: (data) => data.totalPnl !== null ? functoolsKit.str(data.totalPnl, "%+.2f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "sharpeRatio",
-        label: "Sharpe",
-        format: (data) => data.sharpeRatio !== null ? functoolsKit.str(data.sharpeRatio, "%.2f") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "profitFactor",
-        label: "PF",
-        format: (data) => data.profitFactor !== null ? functoolsKit.str(data.profitFactor, "%.2f") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "expectancy",
-        label: "Expect",
-        format: (data) => data.expectancy !== null ? functoolsKit.str(data.expectancy, "%+.2f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "winRate",
-        label: "WR",
-        format: (data) => data.winRate !== null ? functoolsKit.str(data.winRate, "%.1f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "avgWin",
-        label: "Avg Win",
-        format: (data) => data.avgWin !== null ? functoolsKit.str(data.avgWin, "%+.2f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "avgLoss",
-        label: "Avg Loss",
-        format: (data) => data.avgLoss !== null ? functoolsKit.str(data.avgLoss, "%+.2f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "maxDrawdown",
-        label: "Max DD",
-        format: (data) => data.maxDrawdown !== null ? functoolsKit.str(-data.maxDrawdown, "%.2f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "maxWinStreak",
-        label: "W Streak",
-        format: (data) => data.maxWinStreak.toString(),
-        isVisible: () => true,
-    },
-    {
-        key: "maxLossStreak",
-        label: "L Streak",
-        format: (data) => data.maxLossStreak.toString(),
-        isVisible: () => true,
-    },
-    {
-        key: "totalTrades",
-        label: "Trades",
-        format: (data) => data.totalTrades.toString(),
-        isVisible: () => true,
-    },
-];
 /** Maximum number of signals to store per symbol in heatmap reports */
 const MAX_EVENTS$2 = 250;
 /**
@@ -9061,9 +9650,10 @@ class HeatmapStorage {
      * Generates markdown report with portfolio heatmap table (View).
      *
      * @param strategyName - Strategy name for report title
+     * @param columns - Column configuration for formatting the table
      * @returns Promise resolving to markdown formatted report string
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.heat_columns) {
         const data = await this.getData();
         if (data.symbols.length === 0) {
             return [
@@ -9072,10 +9662,15 @@ class HeatmapStorage {
                 "*No data available*"
             ].join("\n");
         }
-        const visibleColumns = columns$2.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = data.symbols.map((row) => visibleColumns.map((col) => col.format(row)));
+        const rows = await Promise.all(data.symbols.map(async (row, index) => Promise.all(visibleColumns.map((col) => col.format(row, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -9091,9 +9686,10 @@ class HeatmapStorage {
      *
      * @param strategyName - Strategy name for filename
      * @param path - Directory path to save report (default: "./dump/heatmap")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path$1 = "./dump/heatmap") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path$1 = "./dump/heatmap", columns = COLUMN_CONFIG.heat_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -9190,6 +9786,7 @@ class HeatMarkdownService {
          * Generates markdown report with portfolio heatmap table for a strategy.
          *
          * @param strategyName - Strategy name to generate heatmap report for
+         * @param columns - Column configuration for formatting the table
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -9209,12 +9806,12 @@ class HeatMarkdownService {
          * // ...
          * ```
          */
-        this.getReport = async (strategyName) => {
+        this.getReport = async (strategyName, columns = COLUMN_CONFIG.heat_columns) => {
             this.loggerService.log(HEATMAP_METHOD_NAME_GET_REPORT, {
                 strategyName,
             });
             const storage = this.getStorage(strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves heatmap report to disk for a strategy.
@@ -9224,6 +9821,7 @@ class HeatMarkdownService {
          *
          * @param strategyName - Strategy name to save heatmap report for
          * @param path - Optional directory path to save report (default: "./dump/heatmap")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -9236,13 +9834,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.
@@ -11096,6 +11694,9 @@ const HANDLE_PROFIT_FN = async (symbol, data, currentPrice, revenuePercent, back
     if (self._states === NEED_FETCH) {
         throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
     }
+    if (data.id !== self.params.signalId) {
+        throw new Error(`Signal ID mismatch: expected ${self.params.signalId}, got ${data.id}`);
+    }
     let state = self._states.get(data.id);
     if (!state) {
         state = {
@@ -11120,7 +11721,7 @@ const HANDLE_PROFIT_FN = async (symbol, data, currentPrice, revenuePercent, back
         }
     }
     if (shouldPersist) {
-        await self._persistState(symbol, backtest);
+        await self._persistState(symbol, data.strategyName);
     }
 };
 /**
@@ -11142,6 +11743,9 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
     if (self._states === NEED_FETCH) {
         throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
     }
+    if (data.id !== self.params.signalId) {
+        throw new Error(`Signal ID mismatch: expected ${self.params.signalId}, got ${data.id}`);
+    }
     let state = self._states.get(data.id);
     if (!state) {
         state = {
@@ -11167,7 +11771,7 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
         }
     }
     if (shouldPersist) {
-        await self._persistState(symbol, backtest);
+        await self._persistState(symbol, data.strategyName);
     }
 };
 /**
@@ -11176,15 +11780,29 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
  * Loads persisted partial state from disk and restores in-memory Maps.
  * Converts serialized arrays back to Sets for O(1) lookups.
  *
+ * ONLY runs in LIVE mode (backtest=false). In backtest mode, state is not persisted.
+ *
  * @param symbol - Trading pair symbol
+ * @param strategyName - Strategy identifier
+ * @param backtest - True if backtest mode, false if live mode
  * @param self - ClientPartial instance reference
  */
-const WAIT_FOR_INIT_FN = async (symbol, self) => {
-    self.params.logger.debug("ClientPartial waitForInit", { symbol });
-    if (self._states === NEED_FETCH) {
-        throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
+const WAIT_FOR_INIT_FN = async (symbol, strategyName, self) => {
+    self.params.logger.debug("ClientPartial waitForInit", {
+        symbol,
+        strategyName,
+        backtest: self.params.backtest
+    });
+    if (self._states !== NEED_FETCH) {
+        throw new Error("ClientPartial WAIT_FOR_INIT_FN should be called once!");
+    }
+    self._states = new Map();
+    // Skip persistence in backtest mode
+    if (self.params.backtest) {
+        self.params.logger.debug("ClientPartial waitForInit: skipping persist read in backtest mode");
+        return;
     }
-    const partialData = await PersistPartialAdapter.readPartialData(symbol);
+    const partialData = await PersistPartialAdapter.readPartialData(symbol, strategyName);
     for (const [signalId, data] of Object.entries(partialData)) {
         const state = {
             profitLevels: new Set(data.profitLevels),
@@ -11194,6 +11812,7 @@ const WAIT_FOR_INIT_FN = async (symbol, self) => {
     }
     self.params.logger.info("ClientPartial restored state", {
         symbol,
+        strategyName,
         signalCount: Object.keys(partialData).length,
     });
 };
@@ -11272,23 +11891,24 @@ class ClientPartial {
         /**
          * Initializes partial state by loading from disk.
          *
-         * Uses singleshot pattern to ensure initialization happens exactly once per symbol.
+         * Uses singleshot pattern to ensure initialization happens exactly once per symbol:strategyName.
          * Reads persisted state from PersistPartialAdapter and restores to _states Map.
          *
          * Must be called before profit()/loss()/clear() methods.
          *
          * @param symbol - Trading pair symbol
+         * @param strategyName - Strategy identifier
+         * @param backtest - True if backtest mode, false if live mode
          * @returns Promise that resolves when initialization is complete
          *
          * @example
          * ```typescript
          * const partial = new ClientPartial(params);
-         * await partial.waitForInit("BTCUSDT"); // Load persisted state
+         * await partial.waitForInit("BTCUSDT", "my-strategy", false); // Load persisted state (live mode)
          * // Now profit()/loss() can be called
          * ```
          */
-        this.waitForInit = functoolsKit.singleshot(async (symbol) => await WAIT_FOR_INIT_FN(symbol, this));
-        this._states = new Map();
+        this.waitForInit = functoolsKit.singleshot(async (symbol, strategyName) => await WAIT_FOR_INIT_FN(symbol, strategyName, this));
     }
     /**
      * Persists current partial state to disk.
@@ -11301,13 +11921,15 @@ class ClientPartial {
      * Uses atomic file writes via PersistPartialAdapter.
      *
      * @param symbol - Trading pair symbol
+     * @param strategyName - Strategy identifier
+     * @param backtest - True if backtest mode
      * @returns Promise that resolves when persistence is complete
      */
-    async _persistState(symbol, backtest) {
-        if (backtest) {
+    async _persistState(symbol, strategyName) {
+        if (this.params.backtest) {
             return;
         }
-        this.params.logger.debug("ClientPartial persistState", { symbol });
+        this.params.logger.debug("ClientPartial persistState", { symbol, strategyName });
         if (this._states === NEED_FETCH) {
             throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
         }
@@ -11318,7 +11940,7 @@ class ClientPartial {
                 lossLevels: Array.from(state.lossLevels),
             };
         }
-        await PersistPartialAdapter.writePartialData(partialData, symbol);
+        await PersistPartialAdapter.writePartialData(partialData, symbol, strategyName);
     }
     /**
      * Processes profit state and emits events for newly reached profit levels.
@@ -11439,8 +12061,11 @@ class ClientPartial {
         if (this._states === NEED_FETCH) {
             throw new Error("ClientPartial not initialized. Call waitForInit() before using.");
         }
+        if (data.id !== this.params.signalId) {
+            throw new Error(`Signal ID mismatch: expected ${this.params.signalId}, got ${data.id}`);
+        }
         this._states.delete(data.id);
-        await this._persistState(symbol, backtest);
+        await this._persistState(symbol, data.strategyName);
     }
 }
 
@@ -11535,15 +12160,17 @@ class PartialConnectionService {
         /**
          * Memoized factory function for ClientPartial instances.
          *
-         * Creates one ClientPartial per signal ID with configured callbacks.
+         * Creates one ClientPartial per signal ID and backtest mode with configured callbacks.
          * Instances are cached until clear() is called.
          *
-         * Key format: signalId
+         * Key format: "signalId:backtest" or "signalId:live"
          * Value: ClientPartial instance with logger and event emitters
          */
-        this.getPartial = functoolsKit.memoize(([signalId]) => `${signalId}`, () => {
+        this.getPartial = functoolsKit.memoize(([signalId, backtest]) => `${signalId}:${backtest ? "backtest" : "live"}`, (signalId, backtest) => {
             return new ClientPartial({
+                signalId,
                 logger: this.loggerService,
+                backtest,
                 onProfit: COMMIT_PROFIT_FN,
                 onLoss: COMMIT_LOSS_FN,
             });
@@ -11571,8 +12198,8 @@ class PartialConnectionService {
                 backtest,
                 when,
             });
-            const partial = this.getPartial(data.id);
-            await partial.waitForInit(symbol);
+            const partial = this.getPartial(data.id, backtest);
+            await partial.waitForInit(symbol, data.strategyName);
             return await partial.profit(symbol, data, currentPrice, revenuePercent, backtest, when);
         };
         /**
@@ -11598,8 +12225,8 @@ class PartialConnectionService {
                 backtest,
                 when,
             });
-            const partial = this.getPartial(data.id);
-            await partial.waitForInit(symbol);
+            const partial = this.getPartial(data.id, backtest);
+            await partial.waitForInit(symbol, data.strategyName);
             return await partial.loss(symbol, data, currentPrice, lossPercent, backtest, when);
         };
         /**
@@ -11620,75 +12247,21 @@ class PartialConnectionService {
          * @returns Promise that resolves when clear is complete
          */
         this.clear = async (symbol, data, priceClose, backtest) => {
-            this.loggerService.log("partialConnectionService profit", {
+            this.loggerService.log("partialConnectionService clear", {
                 symbol,
                 data,
                 priceClose,
+                backtest,
             });
-            const partial = this.getPartial(data.id);
-            await partial.waitForInit(symbol);
+            const partial = this.getPartial(data.id, backtest);
+            await partial.waitForInit(symbol, data.strategyName);
             await partial.clear(symbol, data, priceClose, backtest);
-            this.getPartial.clear(data.id);
+            const key = `${data.id}:${backtest ? "backtest" : "live"}`;
+            this.getPartial.clear(key);
         };
     }
 }
 
-const columns$1 = [
-    {
-        key: "action",
-        label: "Action",
-        format: (data) => data.action.toUpperCase(),
-        isVisible: () => true,
-    },
-    {
-        key: "symbol",
-        label: "Symbol",
-        format: (data) => data.symbol,
-        isVisible: () => true,
-    },
-    {
-        key: "strategyName",
-        label: "Strategy",
-        format: (data) => data.strategyName,
-        isVisible: () => true,
-    },
-    {
-        key: "signalId",
-        label: "Signal ID",
-        format: (data) => data.signalId,
-        isVisible: () => true,
-    },
-    {
-        key: "position",
-        label: "Position",
-        format: (data) => data.position.toUpperCase(),
-        isVisible: () => true,
-    },
-    {
-        key: "level",
-        label: "Level %",
-        format: (data) => data.action === "profit" ? `+${data.level}%` : `-${data.level}%`,
-        isVisible: () => true,
-    },
-    {
-        key: "currentPrice",
-        label: "Current Price",
-        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
-        isVisible: () => true,
-    },
-    {
-        key: "timestamp",
-        label: "Timestamp",
-        format: (data) => new Date(data.timestamp).toISOString(),
-        isVisible: () => true,
-    },
-    {
-        key: "mode",
-        label: "Mode",
-        format: (data) => (data.backtest ? "Backtest" : "Live"),
-        isVisible: () => true,
-    },
-];
 /** Maximum number of events to store in partial reports */
 const MAX_EVENTS$1 = 250;
 /**
@@ -11778,9 +12351,10 @@ let ReportStorage$1 = class ReportStorage {
      *
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all events
      */
-    async getReport(symbol, strategyName) {
+    async getReport(symbol, strategyName, columns = COLUMN_CONFIG.partial_columns) {
         const stats = await this.getData();
         if (stats.totalEvents === 0) {
             return [
@@ -11789,10 +12363,15 @@ let ReportStorage$1 = class ReportStorage {
                 "No partial profit/loss events recorded yet."
             ].join("\n");
         }
-        const visibleColumns = columns$1.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
+        const rows = await Promise.all(this._eventList.map(async (event, index) => Promise.all(visibleColumns.map((col) => col.format(event, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -11811,9 +12390,10 @@ let ReportStorage$1 = class ReportStorage {
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/partial")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(symbol, strategyName, path$1 = "./dump/partial") {
-        const markdown = await this.getReport(symbol, strategyName);
+    async dump(symbol, strategyName, path$1 = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) {
+        const markdown = await this.getReport(symbol, strategyName, columns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -11924,6 +12504,7 @@ class PartialMarkdownService {
          *
          * @param symbol - Trading pair symbol to generate report for
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
@@ -11933,13 +12514,13 @@ class PartialMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.partial_columns) => {
             this.loggerService.log("partialMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(symbol, strategyName);
+            return storage.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -11949,6 +12530,7 @@ class PartialMarkdownService {
          * @param symbol - Trading pair symbol to save report for
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/partial")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -11961,14 +12543,14 @@ class PartialMarkdownService {
          * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/partial") => {
+        this.dump = async (symbol, strategyName, path = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) => {
             this.loggerService.log("partialMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(symbol, strategyName, path);
+            await storage.dump(symbol, strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
@@ -12428,92 +13010,6 @@ class ConfigValidationService {
     }
 }
 
-const columns = [
-    {
-        key: "symbol",
-        label: "Symbol",
-        format: (data) => data.symbol,
-        isVisible: () => true,
-    },
-    {
-        key: "strategyName",
-        label: "Strategy",
-        format: (data) => data.strategyName,
-        isVisible: () => true,
-    },
-    {
-        key: "signalId",
-        label: "Signal ID",
-        format: (data) => data.pendingSignal.id || "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "position",
-        label: "Position",
-        format: (data) => data.pendingSignal.position.toUpperCase(),
-        isVisible: () => true,
-    },
-    {
-        key: "note",
-        label: "Note",
-        format: (data) => toPlainString(data.pendingSignal.note ?? "N/A"),
-        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
-    },
-    {
-        key: "exchangeName",
-        label: "Exchange",
-        format: (data) => data.exchangeName,
-        isVisible: () => true,
-    },
-    {
-        key: "openPrice",
-        label: "Open Price",
-        format: (data) => data.pendingSignal.priceOpen !== undefined
-            ? `${data.pendingSignal.priceOpen.toFixed(8)} USD`
-            : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "takeProfit",
-        label: "Take Profit",
-        format: (data) => data.pendingSignal.priceTakeProfit !== undefined
-            ? `${data.pendingSignal.priceTakeProfit.toFixed(8)} USD`
-            : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "stopLoss",
-        label: "Stop Loss",
-        format: (data) => data.pendingSignal.priceStopLoss !== undefined
-            ? `${data.pendingSignal.priceStopLoss.toFixed(8)} USD`
-            : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "currentPrice",
-        label: "Current Price",
-        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
-        isVisible: () => true,
-    },
-    {
-        key: "activePositionCount",
-        label: "Active Positions",
-        format: (data) => data.activePositionCount.toString(),
-        isVisible: () => true,
-    },
-    {
-        key: "comment",
-        label: "Reason",
-        format: (data) => data.comment,
-        isVisible: () => true,
-    },
-    {
-        key: "timestamp",
-        label: "Timestamp",
-        format: (data) => new Date(data.timestamp).toISOString(),
-        isVisible: () => true,
-    },
-];
 /** Maximum number of events to store in risk reports */
 const MAX_EVENTS = 250;
 /**
@@ -12569,9 +13065,10 @@ class ReportStorage {
      *
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all events
      */
-    async getReport(symbol, strategyName) {
+    async getReport(symbol, strategyName, columns = COLUMN_CONFIG.risk_columns) {
         const stats = await this.getData();
         if (stats.totalRejections === 0) {
             return [
@@ -12580,10 +13077,15 @@ class ReportStorage {
                 "No risk rejections recorded yet.",
             ].join("\n");
         }
-        const visibleColumns = columns.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
+        const rows = await Promise.all(this._eventList.map(async (event, index) => Promise.all(visibleColumns.map((col) => col.format(event, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -12606,9 +13108,10 @@ class ReportStorage {
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/risk")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(symbol, strategyName, path$1 = "./dump/risk") {
-        const markdown = await this.getReport(symbol, strategyName);
+    async dump(symbol, strategyName, path$1 = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) {
+        const markdown = await this.getReport(symbol, strategyName, columns);
         try {
             const dir = path.join(process.cwd(), path$1);
             await fs.mkdir(dir, { recursive: true });
@@ -12700,6 +13203,7 @@ class RiskMarkdownService {
          *
          * @param symbol - Trading pair symbol to generate report for
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
@@ -12709,13 +13213,13 @@ class RiskMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.risk_columns) => {
             this.loggerService.log("riskMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(symbol, strategyName);
+            return storage.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -12725,6 +13229,7 @@ class RiskMarkdownService {
          * @param symbol - Trading pair symbol to save report for
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/risk")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -12737,14 +13242,14 @@ class RiskMarkdownService {
          * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/risk") => {
+        this.dump = async (symbol, strategyName, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) => {
             this.loggerService.log("riskMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(symbol, strategyName, path);
+            await storage.dump(symbol, strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
@@ -12794,6 +13299,118 @@ class RiskMarkdownService {
     }
 }
 
+/**
+ * Service for validating column configurations to ensure consistency with ColumnModel interface
+ * and prevent invalid column definitions.
+ *
+ * Performs comprehensive validation on all column definitions in COLUMN_CONFIG:
+ * - **Required fields**: All columns must have key, label, format, and isVisible properties
+ * - **Unique keys**: All key values must be unique within each column collection
+ * - **Function validation**: format and isVisible must be callable functions
+ * - **Data types**: key and label must be non-empty strings
+ *
+ * @throws {Error} If any validation fails, throws with detailed breakdown of all errors
+ *
+ * @example
+ * ```typescript
+ * const validator = new ColumnValidationService();
+ * validator.validate(); // Throws if column configuration is invalid
+ * ```
+ *
+ * @example Validation failure output:
+ * ```
+ * Column configuration validation failed:
+ *   1. backtest_columns[0]: Missing required field "format"
+ *   2. heat_columns: Duplicate key "symbol" at indexes 1, 5
+ *   3. live_columns[3].isVisible must be a function, got "boolean"
+ * ```
+ */
+class ColumnValidationService {
+    constructor() {
+        /**
+         * @private
+         * @readonly
+         * Injected logger service instance
+         */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Validates all column configurations in COLUMN_CONFIG for structural correctness.
+         *
+         * Checks:
+         * 1. All required fields (key, label, format, isVisible) are present in each column
+         * 2. key and label are non-empty strings
+         * 3. format and isVisible are functions (not other types)
+         * 4. All keys are unique within each column collection
+         *
+         * @throws Error if configuration is invalid
+         */
+        this.validate = () => {
+            this.loggerService.log("columnValidationService validate");
+            const errors = [];
+            // Iterate through all column collections in COLUMN_CONFIG
+            for (const [configKey, columns] of Object.entries(COLUMN_CONFIG)) {
+                if (!Array.isArray(columns)) {
+                    errors.push(`${configKey} is not an array, got ${typeof columns}`);
+                    continue;
+                }
+                // Track keys for uniqueness check
+                const keyMap = new Map();
+                // Validate each column in the collection
+                columns.forEach((column, index) => {
+                    if (!column || typeof column !== "object") {
+                        errors.push(`${configKey}[${index}]: Column must be an object, got ${typeof column}`);
+                        return;
+                    }
+                    // Check for all required fields
+                    const requiredFields = ["key", "label", "format", "isVisible"];
+                    for (const field of requiredFields) {
+                        if (!(field in column)) {
+                            errors.push(`${configKey}[${index}]: Missing required field "${field}"`);
+                        }
+                    }
+                    // Validate key and label are non-empty strings
+                    if (typeof column.key !== "string" || column.key.trim() === "") {
+                        errors.push(`${configKey}[${index}].key must be a non-empty string, got ${typeof column.key === "string" ? `"${column.key}"` : typeof column.key}`);
+                    }
+                    else {
+                        // Track key for uniqueness check
+                        if (!keyMap.has(column.key)) {
+                            keyMap.set(column.key, []);
+                        }
+                        keyMap.get(column.key).push(index);
+                    }
+                    if (typeof column.label !== "string" || column.label.trim() === "") {
+                        errors.push(`${configKey}[${index}].label must be a non-empty string, got ${typeof column.label === "string" ? `"${column.label}"` : typeof column.label}`);
+                    }
+                    // Validate format is a function
+                    if (typeof column.format !== "function") {
+                        errors.push(`${configKey}[${index}].format must be a function, got "${typeof column.format}"`);
+                    }
+                    // Validate isVisible is a function
+                    if (typeof column.isVisible !== "function") {
+                        errors.push(`${configKey}[${index}].isVisible must be a function, got "${typeof column.isVisible}"`);
+                    }
+                });
+                // Check for duplicate keys
+                for (const [key, indexes] of keyMap.entries()) {
+                    if (indexes.length > 1) {
+                        errors.push(`${configKey}: Duplicate key "${key}" at indexes ${indexes.join(", ")}`);
+                    }
+                }
+            }
+            // Throw aggregated errors if any
+            if (errors.length > 0) {
+                const errorMessage = `Column configuration validation failed:\n${errors
+                    .map((e, i) => `  ${i + 1}. ${e}`)
+                    .join("\n")}`;
+                this.loggerService.warn(errorMessage);
+                throw new Error(errorMessage);
+            }
+            this.loggerService.log("columnValidationService validation passed");
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -12865,6 +13482,7 @@ class RiskMarkdownService {
     provide(TYPES.riskValidationService, () => new RiskValidationService());
     provide(TYPES.optimizerValidationService, () => new OptimizerValidationService());
     provide(TYPES.configValidationService, () => new ConfigValidationService());
+    provide(TYPES.columnValidationService, () => new ColumnValidationService());
 }
 {
     provide(TYPES.optimizerTemplateService, () => new OptimizerTemplateService());
@@ -12941,6 +13559,7 @@ const validationServices = {
     riskValidationService: inject(TYPES.riskValidationService),
     optimizerValidationService: inject(TYPES.optimizerValidationService),
     configValidationService: inject(TYPES.configValidationService),
+    columnValidationService: inject(TYPES.columnValidationService),
 };
 const templateServices = {
     optimizerTemplateService: inject(TYPES.optimizerTemplateService),
@@ -13040,6 +13659,77 @@ function getConfig() {
 function getDefaultConfig() {
     return DEFAULT_CONFIG;
 }
+/**
+ * Sets custom column configurations for markdown report generation.
+ *
+ * Allows overriding default column definitions for any report type.
+ * All columns are validated before assignment to ensure structural correctness.
+ *
+ * @param columns - Partial column configuration object to override default column settings
+ * @param _unsafe - Skip column validations - required for testbed
+ *
+ * @example
+ * ```typescript
+ * setColumns({
+ *   backtest_columns: [
+ *     {
+ *       key: "customId",
+ *       label: "Custom ID",
+ *       format: (data) => data.signal.id,
+ *       isVisible: () => true
+ *     }
+ *   ],
+ * });
+ * ```
+ *
+ * @throws {Error} If column configuration is invalid
+ */
+function setColumns(columns, _unsafe) {
+    const prevConfig = Object.assign({}, COLUMN_CONFIG);
+    try {
+        Object.assign(COLUMN_CONFIG, columns);
+        !_unsafe && backtest$1.columnValidationService.validate();
+    }
+    catch (error) {
+        console.warn(`backtest-kit setColumns failed: ${functoolsKit.getErrorMessage(error)}`, columns);
+        Object.assign(COLUMN_CONFIG, prevConfig);
+        throw error;
+    }
+}
+/**
+ * Retrieves a copy of the current column configuration for markdown report generation.
+ *
+ * Returns a shallow copy of the current COLUMN_CONFIG to prevent accidental mutations.
+ * Use this to inspect the current column definitions without modifying them.
+ *
+ * @returns {ColumnConfig} A copy of the current column configuration object
+ *
+ * @example
+ * ```typescript
+ * const currentColumns = getColumns();
+ * console.log(currentColumns.backtest_columns.length);
+ * ```
+ */
+function getColumns() {
+    return Object.assign({}, COLUMN_CONFIG);
+}
+/**
+ * Retrieves the default column configuration object for markdown report generation.
+ *
+ * Returns a reference to the default column definitions with all preset values.
+ * Use this to see what column options are available and their default definitions.
+ *
+ * @returns {ColumnConfig} The default column configuration object
+ *
+ * @example
+ * ```typescript
+ * const defaultColumns = getDefaultColumns();
+ * console.log(defaultColumns.backtest_columns);
+ * ```
+ */
+function getDefaultColumns() {
+    return DEFAULT_COLUMNS;
+}
 
 const ADD_STRATEGY_METHOD_NAME = "add.addStrategy";
 const ADD_EXCHANGE_METHOD_NAME = "add.addExchange";
@@ -14919,12 +15609,12 @@ class BacktestInstance {
                 backtest$1.scheduleMarkdownService.clear({ symbol, strategyName: context.strategyName });
             }
             {
-                backtest$1.strategyCoreService.clear({ symbol, strategyName: context.strategyName });
+                backtest$1.strategyCoreService.clear(true, { symbol, strategyName: context.strategyName });
             }
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
-                riskName && backtest$1.riskGlobalService.clear(riskName);
-                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(riskName));
+                riskName && backtest$1.riskGlobalService.clear(true, riskName);
+                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(true, riskName));
             }
             return backtest$1.backtestCommandService.run(symbol, context);
         };
@@ -14955,9 +15645,9 @@ class BacktestInstance {
             });
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                backtest$1.strategyCoreService.stop({ symbol, strategyName: context.strategyName }, true);
+                backtest$1.strategyCoreService.stop(true, { symbol, strategyName: context.strategyName });
                 backtest$1.strategyCoreService
-                    .getPendingSignal(symbol, context.strategyName)
+                    .getPendingSignal(true, symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
                         return;
@@ -14997,7 +15687,7 @@ class BacktestInstance {
                 symbol,
                 strategyName,
             });
-            await backtest$1.strategyCoreService.stop({ symbol, strategyName }, true);
+            await backtest$1.strategyCoreService.stop(true, { symbol, strategyName });
         };
         /**
          * Gets statistical data from all closed signals for a symbol-strategy pair.
@@ -15025,6 +15715,7 @@ class BacktestInstance {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15034,12 +15725,12 @@ class BacktestInstance {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
             });
-            return await backtest$1.backtestMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.backtestMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15047,6 +15738,7 @@ class BacktestInstance {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/backtest")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15058,13 +15750,13 @@ class BacktestInstance {
          * await instance.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(BACKTEST_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
                 path,
             });
-            await backtest$1.backtestMarkdownService.dump(symbol, strategyName, path);
+            await backtest$1.backtestMarkdownService.dump(symbol, strategyName, path, columns);
         };
     }
 }
@@ -15203,6 +15895,7 @@ class BacktestUtils {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15211,7 +15904,7 @@ class BacktestUtils {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -15219,7 +15912,7 @@ class BacktestUtils {
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, strategyName);
-            return await instance.getReport(symbol, strategyName);
+            return await instance.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15227,6 +15920,7 @@ class BacktestUtils {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/backtest")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15237,7 +15931,7 @@ class BacktestUtils {
          * await Backtest.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -15245,7 +15939,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.
@@ -15419,12 +16113,12 @@ class LiveInstance {
                 backtest$1.scheduleMarkdownService.clear({ symbol, strategyName: context.strategyName });
             }
             {
-                backtest$1.strategyCoreService.clear({ symbol, strategyName: context.strategyName });
+                backtest$1.strategyCoreService.clear(false, { symbol, strategyName: context.strategyName });
             }
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(context.strategyName);
-                riskName && backtest$1.riskGlobalService.clear(riskName);
-                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(riskName));
+                riskName && backtest$1.riskGlobalService.clear(false, riskName);
+                riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(false, riskName));
             }
             return backtest$1.liveCommandService.run(symbol, context);
         };
@@ -15455,9 +16149,9 @@ class LiveInstance {
             });
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
-                backtest$1.strategyCoreService.stop({ symbol, strategyName: context.strategyName }, false);
+                backtest$1.strategyCoreService.stop(false, { symbol, strategyName: context.strategyName });
                 backtest$1.strategyCoreService
-                    .getPendingSignal(symbol, context.strategyName)
+                    .getPendingSignal(false, symbol, context.strategyName)
                     .then(async (pendingSignal) => {
                     if (pendingSignal) {
                         return;
@@ -15497,7 +16191,7 @@ class LiveInstance {
                 symbol,
                 strategyName,
             });
-            await backtest$1.strategyCoreService.stop({ symbol, strategyName }, false);
+            await backtest$1.strategyCoreService.stop(false, { symbol, strategyName });
         };
         /**
          * Gets statistical data from all live trading events for a symbol-strategy pair.
@@ -15525,6 +16219,7 @@ class LiveInstance {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15534,12 +16229,12 @@ class LiveInstance {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
             });
-            return await backtest$1.liveMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.liveMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15547,6 +16242,7 @@ class LiveInstance {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/live")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15558,13 +16254,13 @@ class LiveInstance {
          * await instance.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(LIVE_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
                 path,
             });
-            await backtest$1.liveMarkdownService.dump(symbol, strategyName, path);
+            await backtest$1.liveMarkdownService.dump(symbol, strategyName, path, columns);
         };
     }
 }
@@ -15714,6 +16410,7 @@ class LiveUtils {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15722,7 +16419,7 @@ class LiveUtils {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -15730,7 +16427,7 @@ class LiveUtils {
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, strategyName);
-            return await instance.getReport(symbol, strategyName);
+            return await instance.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15738,6 +16435,7 @@ class LiveUtils {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/live")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15748,7 +16446,7 @@ class LiveUtils {
          * await Live.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -15756,7 +16454,7 @@ class LiveUtils {
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP));
             }
             const instance = this._getInstance(symbol, strategyName);
-            return await instance.dump(symbol, strategyName, path);
+            return await instance.dump(symbol, strategyName, path, columns);
         };
         /**
          * Lists all active live trading instances with their current status.
@@ -15855,6 +16553,7 @@ class ScheduleUtils {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15863,7 +16562,7 @@ class ScheduleUtils {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
@@ -15874,7 +16573,7 @@ class ScheduleUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.scheduleMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.scheduleMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15882,6 +16581,7 @@ class ScheduleUtils {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/schedule")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15892,7 +16592,7 @@ class ScheduleUtils {
          * await Schedule.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
@@ -15904,7 +16604,7 @@ class ScheduleUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP));
             }
-            await backtest$1.scheduleMarkdownService.dump(symbol, strategyName, path);
+            await backtest$1.scheduleMarkdownService.dump(symbol, strategyName, path, columns);
         };
     }
 }
@@ -16004,6 +16704,7 @@ class Performance {
      *
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name to generate report for
+     * @param columns - Optional columns configuration for the report
      * @returns Markdown formatted report string
      *
      * @example
@@ -16016,14 +16717,14 @@ class Performance {
      * await fs.writeFile("performance-report.md", markdown);
      * ```
      */
-    static async getReport(symbol, strategyName) {
+    static async getReport(symbol, strategyName, columns) {
         backtest$1.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_GET_REPORT);
         {
             const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
             riskName && backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT);
             riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT));
         }
-        return backtest$1.performanceMarkdownService.getReport(symbol, strategyName);
+        return backtest$1.performanceMarkdownService.getReport(symbol, strategyName, columns);
     }
     /**
      * Saves performance report to disk.
@@ -16034,6 +16735,7 @@ class Performance {
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name to save report for
      * @param path - Optional custom directory path
+     * @param columns - Optional columns configuration for the report
      *
      * @example
      * ```typescript
@@ -16044,14 +16746,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);
     }
 }
 
@@ -16193,12 +16895,13 @@ class WalkerInstance {
                     backtest$1.scheduleMarkdownService.clear({ symbol, strategyName });
                 }
                 {
-                    backtest$1.strategyCoreService.clear({ symbol, strategyName });
+                    backtest$1.strategyCoreService.clear(true, { symbol, strategyName });
                 }
                 {
                     const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                    riskName && backtest$1.riskGlobalService.clear(riskName);
-                    riskList && riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(riskName));
+                    riskName && backtest$1.riskGlobalService.clear(true, riskName);
+                    riskList &&
+                        riskList.forEach((riskName) => backtest$1.riskGlobalService.clear(true, riskName));
                 }
             }
             return backtest$1.walkerCommandService.run(symbol, {
@@ -16234,8 +16937,12 @@ class WalkerInstance {
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(functoolsKit.getErrorMessage(error))));
             return () => {
                 for (const strategyName of walkerSchema.strategies) {
-                    backtest$1.strategyCoreService.stop({ symbol, strategyName }, true);
-                    walkerStopSubject.next({ symbol, strategyName, walkerName: context.walkerName });
+                    backtest$1.strategyCoreService.stop(true, { symbol, strategyName });
+                    walkerStopSubject.next({
+                        symbol,
+                        strategyName,
+                        walkerName: context.walkerName,
+                    });
                 }
                 if (!this._isDone) {
                     doneWalkerSubject.next({
@@ -16280,7 +16987,7 @@ class WalkerInstance {
             const walkerSchema = backtest$1.walkerSchemaService.get(walkerName);
             for (const strategyName of walkerSchema.strategies) {
                 await walkerStopSubject.next({ symbol, strategyName, walkerName });
-                await backtest$1.strategyCoreService.stop({ symbol, strategyName }, true);
+                await backtest$1.strategyCoreService.stop(true, { symbol, strategyName });
             }
         };
         /**
@@ -16313,6 +17020,8 @@ class WalkerInstance {
          *
          * @param symbol - Trading symbol
          * @param walkerName - Walker name to generate report for
+         * @param strategyColumns - Optional strategy columns configuration
+         * @param pnlColumns - Optional PNL columns configuration
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -16322,7 +17031,7 @@ class WalkerInstance {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, walkerName) => {
+        this.getReport = async (symbol, walkerName, strategyColumns, pnlColumns) => {
             backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_REPORT, {
                 symbol,
                 walkerName,
@@ -16331,7 +17040,7 @@ class WalkerInstance {
             return await backtest$1.walkerMarkdownService.getReport(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
-            });
+            }, strategyColumns, pnlColumns);
         };
         /**
          * Saves walker report to disk.
@@ -16339,6 +17048,8 @@ class WalkerInstance {
          * @param symbol - Trading symbol
          * @param walkerName - Walker name to save report for
          * @param path - Optional directory path to save report (default: "./dump/walker")
+         * @param strategyColumns - Optional strategy columns configuration
+         * @param pnlColumns - Optional PNL columns configuration
          *
          * @example
          * ```typescript
@@ -16350,7 +17061,7 @@ class WalkerInstance {
          * await instance.dump("BTCUSDT", "my-walker", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, walkerName, path) => {
+        this.dump = async (symbol, walkerName, path, strategyColumns, pnlColumns) => {
             backtest$1.loggerService.info(WALKER_METHOD_NAME_DUMP, {
                 symbol,
                 walkerName,
@@ -16360,7 +17071,7 @@ class WalkerInstance {
             await backtest$1.walkerMarkdownService.dump(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
-            }, path);
+            }, path, strategyColumns, pnlColumns);
         };
     }
 }
@@ -16405,8 +17116,10 @@ class WalkerUtils {
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_RUN);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN));
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_RUN));
             }
             const instance = this._getInstance(symbol, context.walkerName);
             return instance.run(symbol, context);
@@ -16438,8 +17151,10 @@ class WalkerUtils {
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_BACKGROUND);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND));
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_BACKGROUND));
             }
             const instance = this._getInstance(symbol, context.walkerName);
             return instance.background(symbol, context);
@@ -16473,8 +17188,10 @@ class WalkerUtils {
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_STOP);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP));
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_STOP));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.stop(symbol, walkerName);
@@ -16498,8 +17215,10 @@ class WalkerUtils {
             for (const strategyName of walkerSchema.strategies) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_DATA);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA));
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_DATA));
             }
             const instance = this._getInstance(symbol, walkerName);
             return await instance.getData(symbol, walkerName);
@@ -16509,6 +17228,8 @@ class WalkerUtils {
          *
          * @param symbol - Trading symbol
          * @param walkerName - Walker name to generate report for
+         * @param strategyColumns - Optional strategy columns configuration
+         * @param pnlColumns - Optional PNL columns configuration
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -16517,17 +17238,19 @@ 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) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_GET_REPORT);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT));
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, walkerName);
-            return await instance.getReport(symbol, walkerName);
+            return await instance.getReport(symbol, walkerName, strategyColumns, pnlColumns);
         };
         /**
          * Saves walker report to disk.
@@ -16535,6 +17258,8 @@ class WalkerUtils {
          * @param symbol - Trading symbol
          * @param walkerName - Walker name to save report for
          * @param path - Optional directory path to save report (default: "./dump/walker")
+         * @param strategyColumns - Optional strategy columns configuration
+         * @param pnlColumns - Optional PNL columns configuration
          *
          * @example
          * ```typescript
@@ -16545,17 +17270,19 @@ 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) {
                 backtest$1.strategyValidationService.validate(strategyName, WALKER_METHOD_NAME_DUMP);
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
-                riskName && backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP);
-                riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP));
+                riskName &&
+                    backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP);
+                riskList &&
+                    riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, WALKER_METHOD_NAME_DUMP));
             }
             const instance = this._getInstance(symbol, walkerName);
-            return await instance.dump(symbol, walkerName, path);
+            return await instance.dump(symbol, walkerName, path, strategyColumns, pnlColumns);
         };
         /**
          * Lists all active walker instances with their current status.
@@ -16661,6 +17388,7 @@ class HeatUtils {
          * Symbols are sorted by Total PNL descending.
          *
          * @param strategyName - Strategy name to generate heatmap report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -16679,7 +17407,7 @@ class HeatUtils {
          * // ...
          * ```
          */
-        this.getReport = async (strategyName) => {
+        this.getReport = async (strategyName, columns) => {
             backtest$1.loggerService.info(HEAT_METHOD_NAME_GET_REPORT, { strategyName });
             backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_GET_REPORT);
             {
@@ -16687,7 +17415,7 @@ class HeatUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.heatMarkdownService.getReport(strategyName);
+            return await backtest$1.heatMarkdownService.getReport(strategyName, columns);
         };
         /**
          * Saves heatmap report to disk for a strategy.
@@ -16697,6 +17425,7 @@ class HeatUtils {
          *
          * @param strategyName - Strategy name to save heatmap report for
          * @param path - Optional directory path to save report (default: "./dump/heatmap")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -16707,7 +17436,7 @@ class HeatUtils {
          * await Heat.dump("my-strategy", "./reports");
          * ```
          */
-        this.dump = async (strategyName, path) => {
+        this.dump = async (strategyName, path, columns) => {
             backtest$1.loggerService.info(HEAT_METHOD_NAME_DUMP, { strategyName, path });
             backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_DUMP);
             {
@@ -16715,7 +17444,7 @@ class HeatUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP));
             }
-            await backtest$1.heatMarkdownService.dump(strategyName, path);
+            await backtest$1.heatMarkdownService.dump(strategyName, path, columns);
         };
     }
 }
@@ -17015,7 +17744,7 @@ class PartialUtils {
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
-         * @returns Promise resolving to PartialStatistics object with counts and event list
+         * @returns Promise resolving to PartialStatisticsModel object with counts and event list
          *
          * @example
          * ```typescript
@@ -17059,6 +17788,7 @@ class PartialUtils {
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -17079,7 +17809,7 @@ class PartialUtils {
          * // **Loss events:** 1
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol, strategyName });
             backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_GET_REPORT);
             {
@@ -17087,7 +17817,7 @@ class PartialUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.partialMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.partialMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Generates and saves markdown report to file.
@@ -17104,6 +17834,7 @@ class PartialUtils {
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
          * @param path - Output directory path (default: "./dump/partial")
+         * @param columns - Optional columns configuration for the report
          * @returns Promise that resolves when file is written
          *
          * @example
@@ -17120,7 +17851,7 @@ class PartialUtils {
          * }
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, strategyName, path });
             backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_DUMP);
             {
@@ -17128,7 +17859,7 @@ class PartialUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP));
             }
-            await backtest$1.partialMarkdownService.dump(symbol, strategyName, path);
+            await backtest$1.partialMarkdownService.dump(symbol, strategyName, path, columns);
         };
     }
 }
@@ -17260,8 +17991,10 @@ exports.formatPrice = formatPrice;
 exports.formatQuantity = formatQuantity;
 exports.getAveragePrice = getAveragePrice;
 exports.getCandles = getCandles;
+exports.getColumns = getColumns;
 exports.getConfig = getConfig;
 exports.getDate = getDate;
+exports.getDefaultColumns = getDefaultColumns;
 exports.getDefaultConfig = getDefaultConfig;
 exports.getMode = getMode;
 exports.lib = backtest;
@@ -17300,5 +18033,6 @@ exports.listenWalker = listenWalker;
 exports.listenWalkerComplete = listenWalkerComplete;
 exports.listenWalkerOnce = listenWalkerOnce;
 exports.listenWalkerProgress = listenWalkerProgress;
+exports.setColumns = setColumns;
 exports.setConfig = setConfig;
 exports.setLogger = setLogger;