backtest-kit 1.5.25 → 1.5.27

package/build/index.mjs

@@ -1,4 +1,4 @@
-import { errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, ToolRegistry, isObject, and, resolveDocuments, str, iterateDocuments, distinctDocuments, queued, singlerun } from 'functools-kit';
+import { str, errorData, getErrorMessage, sleep, memoize, makeExtendable, singleshot, not, trycatch, retry, Subject, randomString, ToolRegistry, isObject, and, resolveDocuments, iterateDocuments, distinctDocuments, queued, singlerun } from 'functools-kit';
 import { createActivator } from 'di-kit';
 import { scoped } from 'di-scoped';
 import fs, { mkdir, writeFile } from 'fs/promises';
@@ -120,6 +120,1081 @@ const GLOBAL_CONFIG = {
 };
 const DEFAULT_CONFIG = Object.freeze({ ...GLOBAL_CONFIG });
 
+/**
+ * Converts markdown content to plain text with minimal formatting
+ * @param content - Markdown string to convert
+ * @returns Plain text representation
+ */
+const toPlainString = (content) => {
+    if (!content) {
+        return "";
+    }
+    let text = content;
+    // Remove code blocks
+    text = text.replace(/```[\s\S]*?```/g, "");
+    text = text.replace(/`([^`]+)`/g, "$1");
+    // Remove images
+    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1");
+    // Convert links to text only (keep link text, remove URL)
+    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
+    // Remove headers (convert to plain text)
+    text = text.replace(/^#{1,6}\s+(.+)$/gm, "$1");
+    // Remove bold and italic markers
+    text = text.replace(/\*\*\*(.+?)\*\*\*/g, "$1");
+    text = text.replace(/\*\*(.+?)\*\*/g, "$1");
+    text = text.replace(/\*(.+?)\*/g, "$1");
+    text = text.replace(/___(.+?)___/g, "$1");
+    text = text.replace(/__(.+?)__/g, "$1");
+    text = text.replace(/_(.+?)_/g, "$1");
+    // Remove strikethrough
+    text = text.replace(/~~(.+?)~~/g, "$1");
+    // Convert lists to plain text with bullets
+    text = text.replace(/^\s*[-*+]\s+/gm, "• ");
+    text = text.replace(/^\s*\d+\.\s+/gm, "• ");
+    // Remove blockquotes
+    text = text.replace(/^\s*>\s+/gm, "");
+    // Remove horizontal rules
+    text = text.replace(/^(\*{3,}|-{3,}|_{3,})$/gm, "");
+    // Remove HTML tags
+    text = text.replace(/<[^>]+>/g, "");
+    // Remove excessive whitespace and normalize line breaks
+    text = text.replace(/\n[\s\n]*\n/g, "\n");
+    text = text.replace(/[ \t]+/g, " ");
+    // Remove all newline characters
+    text = text.replace(/\n/g, " ");
+    // Remove excessive spaces after newline removal
+    text = text.replace(/\s+/g, " ");
+    return text.trim();
+};
+
+/**
+ * Column configuration for backtest markdown reports.
+ *
+ * Defines the table structure for displaying closed trading signals in backtest reports.
+ * Each column specifies how to format and display specific signal data fields.
+ *
+ * Used by {@link BacktestMarkdownService} to generate markdown tables showing:
+ * - Signal identification (ID, symbol, position)
+ * - Price levels (open, close, take profit, stop loss)
+ * - Performance metrics (PNL percentage, close reason)
+ * - Timing information (duration, timestamps)
+ *
+ * @remarks
+ * Columns can be conditionally visible based on {@link GLOBAL_CONFIG} settings.
+ * For example, the "note" column visibility is controlled by `CC_REPORT_SHOW_SIGNAL_NOTE`.
+ *
+ * @example
+ * ```typescript
+ * import { backtest_columns } from "./assets/backtest.columns";
+ *
+ * // Use with BacktestMarkdownService
+ * const service = new BacktestMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", backtest_columns);
+ *
+ * // Or customize columns
+ * const customColumns = backtest_columns.filter(col => col.key !== "note");
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link BacktestMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link IStrategyTickResultClosed} for data structure
+ */
+const backtest_columns = [
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.signal.id,
+        isVisible: () => true,
+    },
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.signal.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.signal.position.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "note",
+        label: "Note",
+        format: (data) => toPlainString(data.signal.note ?? "N/A"),
+        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
+    },
+    {
+        key: "openPrice",
+        label: "Open Price",
+        format: (data) => `${data.signal.priceOpen.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "closePrice",
+        label: "Close Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "takeProfit",
+        label: "Take Profit",
+        format: (data) => `${data.signal.priceTakeProfit.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "stopLoss",
+        label: "Stop Loss",
+        format: (data) => `${data.signal.priceStopLoss.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "pnl",
+        label: "PNL (net)",
+        format: (data) => {
+            const pnlPercentage = data.pnl.pnlPercentage;
+            return `${pnlPercentage > 0 ? "+" : ""}${pnlPercentage.toFixed(2)}%`;
+        },
+        isVisible: () => true,
+    },
+    {
+        key: "closeReason",
+        label: "Close Reason",
+        format: (data) => data.closeReason,
+        isVisible: () => true,
+    },
+    {
+        key: "duration",
+        label: "Duration (min)",
+        format: (data) => {
+            const durationMs = data.closeTimestamp - data.signal.pendingAt;
+            const durationMin = Math.round(durationMs / 60000);
+            return `${durationMin}`;
+        },
+        isVisible: () => true,
+    },
+    {
+        key: "openTimestamp",
+        label: "Open Time",
+        format: (data) => new Date(data.signal.pendingAt).toISOString(),
+        isVisible: () => true,
+    },
+    {
+        key: "closeTimestamp",
+        label: "Close Time",
+        format: (data) => new Date(data.closeTimestamp).toISOString(),
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Column configuration for portfolio heatmap markdown reports.
+ *
+ * Defines the table structure for displaying aggregated per-symbol statistics in portfolio heatmap reports.
+ * Each column specifies how to format and display portfolio performance metrics across different trading symbols.
+ *
+ * Used by {@link HeatMarkdownService} to generate markdown tables showing:
+ * - Symbol identification
+ * - Performance metrics (Total PNL, Sharpe Ratio, Profit Factor, Expectancy)
+ * - Risk metrics (Win Rate, Average Win/Loss, Max Drawdown)
+ * - Trading activity (Total Trades, Win/Loss Streaks)
+ *
+ * @remarks
+ * This configuration is used to create portfolio-wide views that aggregate statistics per symbol.
+ * The heatmap service automatically sorts symbols by Sharpe Ratio (best performers first).
+ *
+ * @example
+ * ```typescript
+ * import { heat_columns } from "./assets/heat.columns";
+ *
+ * // Use with HeatMarkdownService
+ * const service = new HeatMarkdownService();
+ * await service.getReport("my-strategy", heat_columns);
+ *
+ * // Or customize to show only key metrics
+ * const customColumns = heat_columns.filter(col =>
+ *   ["symbol", "totalPnl", "sharpeRatio", "totalTrades"].includes(col.key)
+ * );
+ * await service.getReport("my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link HeatMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link IHeatmapRow} for data structure
+ */
+const heat_columns = [
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "totalPnl",
+        label: "Total PNL",
+        format: (data) => data.totalPnl !== null ? str(data.totalPnl, "%+.2f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "sharpeRatio",
+        label: "Sharpe",
+        format: (data) => data.sharpeRatio !== null ? str(data.sharpeRatio, "%.2f") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "profitFactor",
+        label: "PF",
+        format: (data) => data.profitFactor !== null ? str(data.profitFactor, "%.2f") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "expectancy",
+        label: "Expect",
+        format: (data) => data.expectancy !== null ? str(data.expectancy, "%+.2f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "winRate",
+        label: "WR",
+        format: (data) => data.winRate !== null ? str(data.winRate, "%.1f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgWin",
+        label: "Avg Win",
+        format: (data) => data.avgWin !== null ? str(data.avgWin, "%+.2f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgLoss",
+        label: "Avg Loss",
+        format: (data) => data.avgLoss !== null ? str(data.avgLoss, "%+.2f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "maxDrawdown",
+        label: "Max DD",
+        format: (data) => data.maxDrawdown !== null ? str(-data.maxDrawdown, "%.2f%%") : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "maxWinStreak",
+        label: "W Streak",
+        format: (data) => data.maxWinStreak.toString(),
+        isVisible: () => true,
+    },
+    {
+        key: "maxLossStreak",
+        label: "L Streak",
+        format: (data) => data.maxLossStreak.toString(),
+        isVisible: () => true,
+    },
+    {
+        key: "totalTrades",
+        label: "Trades",
+        format: (data) => data.totalTrades.toString(),
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Column configuration for live trading markdown reports.
+ *
+ * Defines the table structure for displaying real-time trading events in live trading reports.
+ * Each column specifies how to format and display live trading event data fields.
+ *
+ * Used by {@link LiveMarkdownService} to generate markdown tables showing:
+ * - Event information (timestamp, action type)
+ * - Signal identification (symbol, signal ID, position)
+ * - Price data (current price, open price, take profit, stop loss)
+ * - Performance metrics (PNL percentage, close reason, duration)
+ * - Position tracking (percentage to TP/SL)
+ *
+ * @remarks
+ * This configuration tracks all event types: idle, opened, active, and closed signals.
+ * The "note" column visibility is controlled by {@link GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE}.
+ *
+ * @example
+ * ```typescript
+ * import { live_columns } from "./assets/live.columns";
+ *
+ * // Use with LiveMarkdownService
+ * const service = new LiveMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", live_columns);
+ *
+ * // Or customize for minimal display
+ * const customColumns = live_columns.filter(col =>
+ *   ["timestamp", "action", "symbol", "pnl"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link LiveMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link TickEvent} for data structure
+ */
+const live_columns = [
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+        isVisible: () => true,
+    },
+    {
+        key: "action",
+        label: "Action",
+        format: (data) => data.action.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol ?? "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.signalId ?? "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.position?.toUpperCase() ?? "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "note",
+        label: "Note",
+        format: (data) => toPlainString(data.note ?? "N/A"),
+        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
+    },
+    {
+        key: "currentPrice",
+        label: "Current Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "openPrice",
+        label: "Open Price",
+        format: (data) => data.openPrice !== undefined ? `${data.openPrice.toFixed(8)} USD` : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "takeProfit",
+        label: "Take Profit",
+        format: (data) => data.takeProfit !== undefined
+            ? `${data.takeProfit.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "stopLoss",
+        label: "Stop Loss",
+        format: (data) => data.stopLoss !== undefined ? `${data.stopLoss.toFixed(8)} USD` : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "percentTp",
+        label: "% to TP",
+        format: (data) => data.percentTp !== undefined ? `${data.percentTp.toFixed(2)}%` : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "percentSl",
+        label: "% to SL",
+        format: (data) => data.percentSl !== undefined ? `${data.percentSl.toFixed(2)}%` : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "pnl",
+        label: "PNL (net)",
+        format: (data) => {
+            if (data.pnl === undefined)
+                return "N/A";
+            return `${data.pnl > 0 ? "+" : ""}${data.pnl.toFixed(2)}%`;
+        },
+        isVisible: () => true,
+    },
+    {
+        key: "closeReason",
+        label: "Close Reason",
+        format: (data) => data.closeReason ?? "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "duration",
+        label: "Duration (min)",
+        format: (data) => data.duration !== undefined ? `${data.duration}` : "N/A",
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Column configuration for partial profit/loss markdown reports.
+ *
+ * Defines the table structure for displaying partial position exit events in trading reports.
+ * Each column specifies how to format and display partial profit and loss level events.
+ *
+ * Used by {@link PartialMarkdownService} to generate markdown tables showing:
+ * - Event information (action type: profit or loss)
+ * - Signal identification (symbol, strategy name, signal ID, position)
+ * - Exit level information (percentage level reached)
+ * - Price data (current price at partial exit)
+ * - Timing information (timestamp, mode: backtest or live)
+ *
+ * @remarks
+ * This configuration tracks partial position exits at predefined profit/loss levels.
+ * The "note" column visibility is controlled by {@link GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE}.
+ * Useful for analyzing risk management strategies and partial exit performance.
+ *
+ * @example
+ * ```typescript
+ * import { partial_columns } from "./assets/partial.columns";
+ *
+ * // Use with PartialMarkdownService
+ * const service = new PartialMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", partial_columns);
+ *
+ * // Or customize to show only key fields
+ * const customColumns = partial_columns.filter(col =>
+ *   ["action", "symbol", "level", "timestamp"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link PartialMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link PartialEvent} for data structure
+ */
+const partial_columns = [
+    {
+        key: "action",
+        label: "Action",
+        format: (data) => data.action.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "strategyName",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+        isVisible: () => true,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.signalId,
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.position.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "level",
+        label: "Level %",
+        format: (data) => data.action === "profit" ? `+${data.level}%` : `-${data.level}%`,
+        isVisible: () => true,
+    },
+    {
+        key: "currentPrice",
+        label: "Current Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+        isVisible: () => true,
+    },
+    {
+        key: "mode",
+        label: "Mode",
+        format: (data) => (data.backtest ? "Backtest" : "Live"),
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Column configuration for performance metrics markdown reports.
+ *
+ * Defines the table structure for displaying performance statistics and timing metrics in performance reports.
+ * Each column specifies how to format and display aggregated performance data for different metric types.
+ *
+ * Used by {@link PerformanceMarkdownService} to generate markdown tables showing:
+ * - Metric identification (metric type)
+ * - Execution statistics (count, total duration, average, min, max)
+ * - Distribution metrics (standard deviation, median, percentiles)
+ * - Wait time statistics (average, min, max wait times between events)
+ *
+ * @remarks
+ * This configuration helps identify performance bottlenecks in strategy execution.
+ * The service automatically sorts metrics by total duration to highlight the slowest operations.
+ * All durations are measured in milliseconds.
+ *
+ * @example
+ * ```typescript
+ * import { performance_columns } from "./assets/performance.columns";
+ *
+ * // Use with PerformanceMarkdownService
+ * const service = new PerformanceMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", performance_columns);
+ *
+ * // Or customize for bottleneck analysis
+ * const customColumns = performance_columns.filter(col =>
+ *   ["metricType", "count", "avgDuration", "maxDuration", "p95"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link PerformanceMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link MetricStats} for data structure
+ */
+const performance_columns = [
+    {
+        key: "metricType",
+        label: "Metric Type",
+        format: (data) => data.metricType,
+        isVisible: () => true,
+    },
+    {
+        key: "count",
+        label: "Count",
+        format: (data) => data.count.toString(),
+        isVisible: () => true,
+    },
+    {
+        key: "totalDuration",
+        label: "Total (ms)",
+        format: (data) => data.totalDuration.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "avgDuration",
+        label: "Avg (ms)",
+        format: (data) => data.avgDuration.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "minDuration",
+        label: "Min (ms)",
+        format: (data) => data.minDuration.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "maxDuration",
+        label: "Max (ms)",
+        format: (data) => data.maxDuration.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "stdDev",
+        label: "Std Dev (ms)",
+        format: (data) => data.stdDev.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "median",
+        label: "Median (ms)",
+        format: (data) => data.median.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "p95",
+        label: "P95 (ms)",
+        format: (data) => data.p95.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "p99",
+        label: "P99 (ms)",
+        format: (data) => data.p99.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "avgWaitTime",
+        label: "Avg Wait (ms)",
+        format: (data) => data.avgWaitTime.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "minWaitTime",
+        label: "Min Wait (ms)",
+        format: (data) => data.minWaitTime.toFixed(2),
+        isVisible: () => true,
+    },
+    {
+        key: "maxWaitTime",
+        label: "Max Wait (ms)",
+        format: (data) => data.maxWaitTime.toFixed(2),
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Column configuration for risk management markdown reports.
+ *
+ * Defines the table structure for displaying risk rejection events in risk management reports.
+ * Each column specifies how to format and display signals that were rejected due to risk limits.
+ *
+ * Used by {@link RiskMarkdownService} to generate markdown tables showing:
+ * - Signal identification (symbol, strategy name, signal ID, position)
+ * - Exchange information (exchange name, active position count)
+ * - Price data (open price, take profit, stop loss, current price)
+ * - Rejection details (rejection reason/comment, timestamp)
+ *
+ * @remarks
+ * This configuration helps analyze when and why the risk management system rejected signals.
+ * The "note" column visibility is controlled by {@link GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE}.
+ * Useful for tuning risk parameters and understanding risk control effectiveness.
+ *
+ * @example
+ * ```typescript
+ * import { risk_columns } from "./assets/risk.columns";
+ *
+ * // Use with RiskMarkdownService
+ * const service = new RiskMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", risk_columns);
+ *
+ * // Or customize to focus on rejection reasons
+ * const customColumns = risk_columns.filter(col =>
+ *   ["symbol", "strategyName", "comment", "activePositionCount", "timestamp"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link RiskMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link RiskEvent} for data structure
+ */
+const risk_columns = [
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "strategyName",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+        isVisible: () => true,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.pendingSignal.id || "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.pendingSignal.position.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "note",
+        label: "Note",
+        format: (data) => toPlainString(data.pendingSignal.note ?? "N/A"),
+        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
+    },
+    {
+        key: "exchangeName",
+        label: "Exchange",
+        format: (data) => data.exchangeName,
+        isVisible: () => true,
+    },
+    {
+        key: "openPrice",
+        label: "Open Price",
+        format: (data) => data.pendingSignal.priceOpen !== undefined
+            ? `${data.pendingSignal.priceOpen.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "takeProfit",
+        label: "Take Profit",
+        format: (data) => data.pendingSignal.priceTakeProfit !== undefined
+            ? `${data.pendingSignal.priceTakeProfit.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "stopLoss",
+        label: "Stop Loss",
+        format: (data) => data.pendingSignal.priceStopLoss !== undefined
+            ? `${data.pendingSignal.priceStopLoss.toFixed(8)} USD`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "currentPrice",
+        label: "Current Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "activePositionCount",
+        label: "Active Positions",
+        format: (data) => data.activePositionCount.toString(),
+        isVisible: () => true,
+    },
+    {
+        key: "comment",
+        label: "Reason",
+        format: (data) => data.comment,
+        isVisible: () => true,
+    },
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Column configuration for scheduled signals markdown reports.
+ *
+ * Defines the table structure for displaying scheduled, opened, and cancelled signal events.
+ * Each column specifies how to format and display signal scheduling and activation data.
+ *
+ * Used by {@link ScheduleMarkdownService} to generate markdown tables showing:
+ * - Event information (timestamp, action: scheduled/opened/cancelled)
+ * - Signal identification (symbol, signal ID, position)
+ * - Price data (current price, entry price, take profit, stop loss)
+ * - Timing information (wait time in minutes before activation or cancellation)
+ *
+ * @remarks
+ * This configuration tracks the lifecycle of scheduled signals from creation to activation or cancellation.
+ * The "note" column visibility is controlled by {@link GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE}.
+ * Helps analyze signal scheduling effectiveness and cancellation patterns.
+ *
+ * @example
+ * ```typescript
+ * import { schedule_columns } from "./assets/schedule.columns";
+ *
+ * // Use with ScheduleMarkdownService
+ * const service = new ScheduleMarkdownService();
+ * await service.getReport("BTCUSDT", "my-strategy", schedule_columns);
+ *
+ * // Or customize for timing analysis
+ * const customColumns = schedule_columns.filter(col =>
+ *   ["timestamp", "action", "symbol", "duration"].includes(col.key)
+ * );
+ * await service.getReport("BTCUSDT", "my-strategy", customColumns);
+ * ```
+ *
+ * @see {@link ScheduleMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link ScheduledEvent} for data structure
+ */
+const schedule_columns = [
+    {
+        key: "timestamp",
+        label: "Timestamp",
+        format: (data) => new Date(data.timestamp).toISOString(),
+        isVisible: () => true,
+    },
+    {
+        key: "action",
+        label: "Action",
+        format: (data) => data.action.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.signalId,
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.position.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "note",
+        label: "Note",
+        format: (data) => toPlainString(data.note ?? "N/A"),
+        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
+    },
+    {
+        key: "currentPrice",
+        label: "Current Price",
+        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "priceOpen",
+        label: "Entry Price",
+        format: (data) => `${data.priceOpen.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "takeProfit",
+        label: "Take Profit",
+        format: (data) => `${data.takeProfit.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "stopLoss",
+        label: "Stop Loss",
+        format: (data) => `${data.stopLoss.toFixed(8)} USD`,
+        isVisible: () => true,
+    },
+    {
+        key: "duration",
+        label: "Wait Time (min)",
+        format: (data) => data.duration !== undefined ? `${data.duration}` : "N/A",
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Column configuration for walker strategy comparison table in markdown reports.
+ *
+ * Defines the table structure for displaying strategy comparison results in walker backtest reports.
+ * Each column specifies how to format and display aggregated strategy performance metrics.
+ *
+ * Used by {@link WalkerMarkdownService} to generate markdown tables showing:
+ * - Strategy ranking and identification
+ * - Optimization metric value (generic "Metric" column)
+ * - Performance statistics (Total Signals, Win Rate, Average PNL, Total PNL)
+ * - Risk metrics (Sharpe Ratio, Standard Deviation)
+ *
+ * @remarks
+ * This configuration is used in walker reports to compare multiple strategy configurations.
+ * The "Metric" column displays the value of the metric being optimized (Sharpe, PNL, etc.).
+ * Strategies are automatically sorted by metric value (best performers first).
+ *
+ * @example
+ * ```typescript
+ * import { walker_strategy_columns } from "./assets/walker.columns";
+ *
+ * // Use with WalkerMarkdownService for strategy comparison
+ * const service = new WalkerMarkdownService();
+ * await service.getReport(
+ *   "my-walker",
+ *   "BTCUSDT",
+ *   "sharpeRatio",
+ *   { exchangeName: "binance", frameName: "1d" },
+ *   walker_strategy_columns
+ * );
+ * ```
+ *
+ * @see {@link WalkerMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link IStrategyResult} for data structure
+ */
+const walker_strategy_columns = [
+    {
+        key: "rank",
+        label: "Rank",
+        format: (_data, index) => `${index + 1}`,
+        isVisible: () => true,
+    },
+    {
+        key: "strategy",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+        isVisible: () => true,
+    },
+    {
+        key: "metric",
+        label: "Metric",
+        format: (data) => data.metricValue !== null ? data.metricValue.toFixed(2) : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalSignals",
+        label: "Total Signals",
+        format: (data) => `${data.stats.totalSignals}`,
+        isVisible: () => true,
+    },
+    {
+        key: "winRate",
+        label: "Win Rate",
+        format: (data) => data.stats.winRate !== null
+            ? `${data.stats.winRate.toFixed(2)}%`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "avgPnl",
+        label: "Avg PNL",
+        format: (data) => data.stats.avgPnl !== null
+            ? `${data.stats.avgPnl > 0 ? "+" : ""}${data.stats.avgPnl.toFixed(2)}%`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "totalPnl",
+        label: "Total PNL",
+        format: (data) => data.stats.totalPnl !== null
+            ? `${data.stats.totalPnl > 0 ? "+" : ""}${data.stats.totalPnl.toFixed(2)}%`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "sharpeRatio",
+        label: "Sharpe Ratio",
+        format: (data) => data.stats.sharpeRatio !== null
+            ? `${data.stats.sharpeRatio.toFixed(3)}`
+            : "N/A",
+        isVisible: () => true,
+    },
+    {
+        key: "stdDev",
+        label: "Std Dev",
+        format: (data) => data.stats.stdDev !== null
+            ? `${data.stats.stdDev.toFixed(3)}%`
+            : "N/A",
+        isVisible: () => true,
+    },
+];
+/**
+ * Column configuration for walker PNL table in markdown reports.
+ *
+ * Defines the table structure for displaying all closed signals across all strategies in walker backtest reports.
+ * Each column specifies how to format and display individual signal trade data.
+ *
+ * Used by {@link WalkerMarkdownService} to generate markdown tables showing:
+ * - Strategy identification for each signal
+ * - Signal details (signal ID, symbol, position)
+ * - Trade performance (PNL percentage, close reason)
+ * - Timing information (open time, close time)
+ *
+ * @remarks
+ * This configuration aggregates all signals from all tested strategies into a single comprehensive table.
+ * Useful for detailed analysis of individual trades across different strategy configurations.
+ *
+ * @example
+ * ```typescript
+ * import { walker_pnl_columns } from "./assets/walker.columns";
+ *
+ * // Use with WalkerMarkdownService for signal-level analysis
+ * const service = new WalkerMarkdownService();
+ * await service.getReport(
+ *   "my-walker",
+ *   "BTCUSDT",
+ *   "sharpeRatio",
+ *   { exchangeName: "binance", frameName: "1d" },
+ *   undefined, // use default strategy columns
+ *   walker_pnl_columns
+ * );
+ * ```
+ *
+ * @see {@link WalkerMarkdownService} for usage in report generation
+ * @see {@link ColumnModel} for column interface definition
+ * @see {@link SignalData} for data structure
+ */
+const walker_pnl_columns = [
+    {
+        key: "strategy",
+        label: "Strategy",
+        format: (data) => data.strategyName,
+        isVisible: () => true,
+    },
+    {
+        key: "signalId",
+        label: "Signal ID",
+        format: (data) => data.signalId,
+        isVisible: () => true,
+    },
+    {
+        key: "symbol",
+        label: "Symbol",
+        format: (data) => data.symbol,
+        isVisible: () => true,
+    },
+    {
+        key: "position",
+        label: "Position",
+        format: (data) => data.position.toUpperCase(),
+        isVisible: () => true,
+    },
+    {
+        key: "pnl",
+        label: "PNL (net)",
+        format: (data) => `${data.pnl > 0 ? "+" : ""}${data.pnl.toFixed(2)}%`,
+        isVisible: () => true,
+    },
+    {
+        key: "closeReason",
+        label: "Close Reason",
+        format: (data) => data.closeReason,
+        isVisible: () => true,
+    },
+    {
+        key: "openTime",
+        label: "Open Time",
+        format: (data) => new Date(data.openTime).toISOString(),
+        isVisible: () => true,
+    },
+    {
+        key: "closeTime",
+        label: "Close Time",
+        format: (data) => new Date(data.closeTime).toISOString(),
+        isVisible: () => true,
+    },
+];
+
+/**
+ * Mapping of available table/markdown reports to their column definitions.
+ *
+ * Each property references a column definition object imported from
+ * `src/assets/*.columns`. These are used by markdown/report generators
+ * (backtest, live, schedule, risk, heat, performance, partial, walker).
+ */
+const COLUMN_CONFIG = {
+    /** Columns used in backtest markdown tables and reports */
+    backtest_columns,
+    /** Columns used by heatmap / heat reports */
+    heat_columns,
+    /** Columns for live trading reports and logs */
+    live_columns,
+    /** Columns for partial-results / incremental reports */
+    partial_columns,
+    /** Columns for performance summary reports */
+    performance_columns,
+    /** Columns for risk-related reports */
+    risk_columns,
+    /** Columns for scheduled report output */
+    schedule_columns,
+    /** Walker: PnL summary columns */
+    walker_pnl_columns,
+    /** Walker: strategy-level summary columns */
+    walker_strategy_columns,
+};
+/**
+ * Immutable default columns mapping used across the application.
+ * Use `DEFAULT_COLUMNS` when you need a read-only reference to the
+ * canonical column configuration.
+ */
+const DEFAULT_COLUMNS = Object.freeze({ ...COLUMN_CONFIG });
+
 const { init, inject, provide } = createActivator("backtest");
 
 /**
@@ -219,6 +1294,7 @@ const validationServices$1 = {
     riskValidationService: Symbol('riskValidationService'),
     optimizerValidationService: Symbol('optimizerValidationService'),
     configValidationService: Symbol('configValidationService'),
+    columnValidationService: Symbol('columnValidationService'),
 };
 const templateServices$1 = {
     optimizerTemplateService: Symbol('optimizerTemplateService'),
@@ -1550,7 +2626,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
@@ -1560,23 +2636,25 @@ const PersistScheduleAdapter = new PersistScheduleUtils();
 class PersistPartialUtils {
     constructor() {
         this.PersistPartialFactory = PersistBase;
-        this.getPartialStorage = memoize(([symbol]) => `${symbol}`, (symbol) => Reflect.construct(this.PersistPartialFactory, [
-            symbol,
+        this.getPartialStorage = 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)) {
@@ -1592,12 +2670,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);
@@ -1632,10 +2712,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();
@@ -1763,53 +2843,6 @@ var emitters = /*#__PURE__*/Object.freeze({
     walkerStopSubject: walkerStopSubject
 });
 
-/**
- * Converts markdown content to plain text with minimal formatting
- * @param content - Markdown string to convert
- * @returns Plain text representation
- */
-const toPlainString = (content) => {
-    if (!content) {
-        return "";
-    }
-    let text = content;
-    // Remove code blocks
-    text = text.replace(/```[\s\S]*?```/g, "");
-    text = text.replace(/`([^`]+)`/g, "$1");
-    // Remove images
-    text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, "$1");
-    // Convert links to text only (keep link text, remove URL)
-    text = text.replace(/\[([^\]]+)\]\([^)]+\)/g, "$1");
-    // Remove headers (convert to plain text)
-    text = text.replace(/^#{1,6}\s+(.+)$/gm, "$1");
-    // Remove bold and italic markers
-    text = text.replace(/\*\*\*(.+?)\*\*\*/g, "$1");
-    text = text.replace(/\*\*(.+?)\*\*/g, "$1");
-    text = text.replace(/\*(.+?)\*/g, "$1");
-    text = text.replace(/___(.+?)___/g, "$1");
-    text = text.replace(/__(.+?)__/g, "$1");
-    text = text.replace(/_(.+?)_/g, "$1");
-    // Remove strikethrough
-    text = text.replace(/~~(.+?)~~/g, "$1");
-    // Convert lists to plain text with bullets
-    text = text.replace(/^\s*[-*+]\s+/gm, "• ");
-    text = text.replace(/^\s*\d+\.\s+/gm, "• ");
-    // Remove blockquotes
-    text = text.replace(/^\s*>\s+/gm, "");
-    // Remove horizontal rules
-    text = text.replace(/^(\*{3,}|-{3,}|_{3,})$/gm, "");
-    // Remove HTML tags
-    text = text.replace(/<[^>]+>/g, "");
-    // Remove excessive whitespace and normalize line breaks
-    text = text.replace(/\n[\s\n]*\n/g, "\n");
-    text = text.replace(/[ \t]+/g, " ");
-    // Remove all newline characters
-    text = text.replace(/\n/g, " ");
-    // Remove excessive spaces after newline removal
-    text = text.replace(/\s+/g, " ");
-    return text.trim();
-};
-
 const INTERVAL_MINUTES$1 = {
     "1m": 1,
     "3m": 3,
@@ -3388,7 +4421,7 @@ class RiskUtils {
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
-         * @returns Promise resolving to RiskStatistics object with counts and event list
+         * @returns Promise resolving to RiskStatisticsModel object with counts and event list
          *
          * @example
          * ```typescript
@@ -3435,6 +4468,7 @@ class RiskUtils {
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -3458,7 +4492,7 @@ class RiskUtils {
          * // - my-strategy: 1
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(RISK_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
@@ -3470,7 +4504,7 @@ class RiskUtils {
                     backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, RISK_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.riskMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.riskMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Generates and saves markdown report to file.
@@ -3487,6 +4521,7 @@ class RiskUtils {
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
          * @param path - Output directory path (default: "./dump/risk")
+         * @param columns - Optional columns configuration for the report
          * @returns Promise that resolves when file is written
          *
          * @example
@@ -3503,7 +4538,7 @@ class RiskUtils {
          * }
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(RISK_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
@@ -3516,7 +4551,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);
         };
     }
 }
@@ -3541,25 +4576,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)),
     ]);
 };
 /**
@@ -3601,7 +4636,7 @@ class StrategyConnectionService {
          * @param strategyName - Name of registered strategy schema
          * @returns Configured ClientStrategy instance
          */
-        this.getStrategy = memoize(([symbol, strategyName]) => `${symbol}:${strategyName}`, (symbol, strategyName) => {
+        this.getStrategy = 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,
@@ -3614,7 +4649,7 @@ class StrategyConnectionService {
                 risk: GET_RISK_FN({
                     riskName,
                     riskList,
-                }, this),
+                }, backtest, this),
                 riskName,
                 strategyName,
                 getSignal,
@@ -3631,12 +4666,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);
         };
         /**
@@ -3649,12 +4685,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);
         };
         /**
@@ -3672,7 +4709,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);
             {
@@ -3703,7 +4741,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);
             {
@@ -3724,11 +4763,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);
         };
         /**
@@ -3739,12 +4778,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 {
@@ -4139,9 +5178,15 @@ const DO_VALIDATION_FN = 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);
 };
@@ -4189,6 +5234,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();
@@ -4234,8 +5280,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();
         }
@@ -4249,6 +5299,7 @@ class ClientRisk {
         this.params.logger.debug("ClientRisk addSignal", {
             symbol,
             context,
+            backtest: this.params.backtest,
         });
         if (this._activePositions === POSITION_NEED_FETCH) {
             await this.waitForInit();
@@ -4271,6 +5322,7 @@ class ClientRisk {
         this.params.logger.debug("ClientRisk removeSignal", {
             symbol,
             context,
+            backtest: this.params.backtest,
         });
         if (this._activePositions === POSITION_NEED_FETCH) {
             await this.waitForInit();
@@ -4341,19 +5393,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 = memoize(([riskName]) => `${riskName}`, (riskName) => {
+        this.getRisk = 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,
             });
         });
@@ -4365,7 +5419,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) => {
@@ -4373,46 +5427,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);
         };
     }
 }
@@ -4635,7 +5691,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,
@@ -4644,7 +5700,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.
@@ -4656,16 +5712,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.
@@ -4739,13 +5796,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.
@@ -4755,14 +5812,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);
         };
     }
 }
@@ -4903,14 +5960,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);
         };
     }
 }
@@ -5033,6 +6091,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}`);
             }
@@ -5441,7 +6512,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(),
@@ -5466,7 +6537,7 @@ class BacktestLogicPrivateService {
                 continue;
             }
             // Check if strategy should stop when idle (no active signal)
-            if (await and(Promise.resolve(result.action === "idle"), this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+            if (await 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(),
@@ -5568,7 +6639,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,
@@ -5661,7 +6732,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,
@@ -5804,7 +6875,7 @@ class LiveLogicPrivateService {
             previousEventTimestamp = currentTimestamp;
             // Check if strategy should stop when idle (no active signal)
             if (result.action === "idle") {
-                if (await and(Promise.resolve(true), this.strategyCoreService.getStopped(symbol, this.methodContextService.context.strategyName))) {
+                if (await 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(),
@@ -5826,7 +6897,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,
@@ -6274,167 +7345,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;
 /**
@@ -6528,9 +7512,10 @@ let ReportStorage$5 = class ReportStorage {
      * Generates markdown report with all closed signals for a strategy (View).
      *
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all signals
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.backtest_columns) {
         const stats = await this.getData();
         if (stats.totalSignals === 0) {
             return [
@@ -6539,10 +7524,15 @@ let ReportStorage$5 = class ReportStorage {
                 "No signals closed yet."
             ].join("\n");
         }
-        const visibleColumns = columns$6.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._signalList.map((closedSignal) => visibleColumns.map((col) => col.format(closedSignal)));
+        const rows = await Promise.all(this._signalList.map(async (closedSignal, index) => Promise.all(visibleColumns.map((col) => col.format(closedSignal, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map(row => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -6567,9 +7557,10 @@ let ReportStorage$5 = class ReportStorage {
      *
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/backtest")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path = "./dump/backtest") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -6677,6 +7668,7 @@ class BacktestMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all closed signals
          *
          * @example
@@ -6686,13 +7678,13 @@ class BacktestMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.backtest_columns) => {
             this.loggerService.log("backtestMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -6702,6 +7694,7 @@ class BacktestMarkdownService {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/backtest")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -6714,14 +7707,14 @@ class BacktestMarkdownService {
          * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/backtest") => {
+        this.dump = async (symbol, strategyName, path = "./dump/backtest", columns = COLUMN_CONFIG.backtest_columns) => {
             this.loggerService.log("backtestMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(strategyName, path);
+            await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated signal data from storage.
@@ -6789,104 +7782,6 @@ function isUnsafe$2(value) {
     }
     return false;
 }
-const columns$5 = [
-    {
-        key: "timestamp",
-        label: "Timestamp",
-        format: (data) => new Date(data.timestamp).toISOString(),
-        isVisible: () => true,
-    },
-    {
-        key: "action",
-        label: "Action",
-        format: (data) => data.action.toUpperCase(),
-        isVisible: () => true,
-    },
-    {
-        key: "symbol",
-        label: "Symbol",
-        format: (data) => data.symbol ?? "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "signalId",
-        label: "Signal ID",
-        format: (data) => data.signalId ?? "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "position",
-        label: "Position",
-        format: (data) => data.position?.toUpperCase() ?? "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "note",
-        label: "Note",
-        format: (data) => toPlainString(data.note ?? "N/A"),
-        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
-    },
-    {
-        key: "currentPrice",
-        label: "Current Price",
-        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
-        isVisible: () => true,
-    },
-    {
-        key: "openPrice",
-        label: "Open Price",
-        format: (data) => data.openPrice !== undefined ? `${data.openPrice.toFixed(8)} USD` : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "takeProfit",
-        label: "Take Profit",
-        format: (data) => data.takeProfit !== undefined
-            ? `${data.takeProfit.toFixed(8)} USD`
-            : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "stopLoss",
-        label: "Stop Loss",
-        format: (data) => data.stopLoss !== undefined ? `${data.stopLoss.toFixed(8)} USD` : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "percentTp",
-        label: "% to TP",
-        format: (data) => data.percentTp !== undefined ? `${data.percentTp.toFixed(2)}%` : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "percentSl",
-        label: "% to SL",
-        format: (data) => data.percentSl !== undefined ? `${data.percentSl.toFixed(2)}%` : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "pnl",
-        label: "PNL (net)",
-        format: (data) => {
-            if (data.pnl === undefined)
-                return "N/A";
-            return `${data.pnl > 0 ? "+" : ""}${data.pnl.toFixed(2)}%`;
-        },
-        isVisible: () => true,
-    },
-    {
-        key: "closeReason",
-        label: "Close Reason",
-        format: (data) => data.closeReason ?? "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "duration",
-        label: "Duration (min)",
-        format: (data) => data.duration !== undefined ? `${data.duration}` : "N/A",
-        isVisible: () => true,
-    },
-];
 /** Maximum number of events to store in live trading reports */
 const MAX_EVENTS$5 = 250;
 /**
@@ -7098,9 +7993,10 @@ let ReportStorage$4 = class ReportStorage {
      * Generates markdown report with all tick events for a strategy (View).
      *
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all events
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.live_columns) {
         const stats = await this.getData();
         if (stats.totalEvents === 0) {
             return [
@@ -7109,10 +8005,15 @@ let ReportStorage$4 = class ReportStorage {
                 "No events recorded yet."
             ].join("\n");
         }
-        const visibleColumns = columns$5.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
+        const rows = await Promise.all(this._eventList.map(async (event, index) => Promise.all(visibleColumns.map((col) => col.format(event, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map(row => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -7137,9 +8038,10 @@ let ReportStorage$4 = class ReportStorage {
      *
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/live")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path = "./dump/live") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path = "./dump/live", columns = COLUMN_CONFIG.live_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -7260,6 +8162,7 @@ class LiveMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
@@ -7269,13 +8172,13 @@ class LiveMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.live_columns) => {
             this.loggerService.log("liveMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -7285,6 +8188,7 @@ class LiveMarkdownService {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/live")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -7297,14 +8201,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.
@@ -7340,88 +8244,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 = 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 = 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;
 /**
@@ -7566,9 +8402,10 @@ let ReportStorage$3 = class ReportStorage {
      * Generates markdown report with all scheduled events for a strategy (View).
      *
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all events
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.schedule_columns) {
         const stats = await this.getData();
         if (stats.totalEvents === 0) {
             return [
@@ -7577,10 +8414,15 @@ let ReportStorage$3 = class ReportStorage {
                 "No scheduled signals recorded yet."
             ].join("\n");
         }
-        const visibleColumns = columns$4.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
+        const rows = await Promise.all(this._eventList.map(async (event, index) => Promise.all(visibleColumns.map((col) => col.format(event, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -7603,9 +8445,10 @@ let ReportStorage$3 = class ReportStorage {
      *
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/schedule")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path = "./dump/schedule") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -7711,6 +8554,7 @@ class ScheduleMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
@@ -7720,13 +8564,13 @@ class ScheduleMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.schedule_columns) => {
             this.loggerService.log("scheduleMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -7736,6 +8580,7 @@ class ScheduleMarkdownService {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/schedule")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -7748,14 +8593,14 @@ class ScheduleMarkdownService {
          * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/schedule") => {
+        this.dump = async (symbol, strategyName, path = "./dump/schedule", columns = COLUMN_CONFIG.schedule_columns) => {
             this.loggerService.log("scheduleMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(strategyName, path);
+            await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
@@ -7814,86 +8659,6 @@ function percentile(sortedArray, p) {
     const index = Math.ceil((sortedArray.length * p) / 100) - 1;
     return sortedArray[Math.max(0, index)];
 }
-const columns$3 = [
-    {
-        key: "metricType",
-        label: "Metric Type",
-        format: (data) => data.metricType,
-        isVisible: () => true,
-    },
-    {
-        key: "count",
-        label: "Count",
-        format: (data) => data.count.toString(),
-        isVisible: () => true,
-    },
-    {
-        key: "totalDuration",
-        label: "Total (ms)",
-        format: (data) => data.totalDuration.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "avgDuration",
-        label: "Avg (ms)",
-        format: (data) => data.avgDuration.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "minDuration",
-        label: "Min (ms)",
-        format: (data) => data.minDuration.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "maxDuration",
-        label: "Max (ms)",
-        format: (data) => data.maxDuration.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "stdDev",
-        label: "Std Dev (ms)",
-        format: (data) => data.stdDev.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "median",
-        label: "Median (ms)",
-        format: (data) => data.median.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "p95",
-        label: "P95 (ms)",
-        format: (data) => data.p95.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "p99",
-        label: "P99 (ms)",
-        format: (data) => data.p99.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "avgWaitTime",
-        label: "Avg Wait (ms)",
-        format: (data) => data.avgWaitTime.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "minWaitTime",
-        label: "Min Wait (ms)",
-        format: (data) => data.minWaitTime.toFixed(2),
-        isVisible: () => true,
-    },
-    {
-        key: "maxWaitTime",
-        label: "Max Wait (ms)",
-        format: (data) => data.maxWaitTime.toFixed(2),
-        isVisible: () => true,
-    },
-];
 /** Maximum number of performance events to store per strategy */
 const MAX_EVENTS$3 = 10000;
 /**
@@ -7996,9 +8761,10 @@ class PerformanceStorage {
      * Generates markdown report with performance statistics.
      *
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.performance_columns) {
         const stats = await this.getData(strategyName);
         if (stats.totalEvents === 0) {
             return [
@@ -8010,10 +8776,15 @@ class PerformanceStorage {
         // Sort metrics by total duration (descending) to show bottlenecks first
         const sortedMetrics = Object.values(stats.metricStats).sort((a, b) => b.totalDuration - a.totalDuration);
         // Generate summary table using Column interface
-        const visibleColumns = columns$3.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = sortedMetrics.map((metric) => visibleColumns.map((col) => col.format(metric)));
+        const rows = await Promise.all(sortedMetrics.map(async (metric, index) => Promise.all(visibleColumns.map((col) => col.format(metric, index)))));
         const tableData = [header, separator, ...rows];
         const summaryTable = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         // Calculate percentage of total time for each metric
@@ -8044,9 +8815,10 @@ class PerformanceStorage {
      *
      * @param strategyName - Strategy name
      * @param path - Directory path to save report
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path = "./dump/performance") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -8139,6 +8911,7 @@ class PerformanceMarkdownService {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string
          *
          * @example
@@ -8147,13 +8920,13 @@ class PerformanceMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.performance_columns) => {
             this.loggerService.log("performanceMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves performance report to disk.
@@ -8161,6 +8934,7 @@ class PerformanceMarkdownService {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -8171,14 +8945,14 @@ class PerformanceMarkdownService {
          * await performanceService.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/performance") => {
+        this.dump = async (symbol, strategyName, path = "./dump/performance", columns = COLUMN_CONFIG.performance_columns) => {
             this.loggerService.log("performanceMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(strategyName, path);
+            await storage.dump(strategyName, path, columns);
         };
         /**
          * Clears accumulated performance data from storage.
@@ -8237,135 +9011,6 @@ function formatMetric(value) {
     }
     return value.toFixed(2);
 }
-/**
- * Creates strategy comparison columns based on metric name.
- * Dynamically builds column configuration with metric-specific header.
- *
- * @param metric - Metric being optimized
- * @returns Array of column configurations for strategy comparison table
- */
-function createStrategyColumns(metric) {
-    return [
-        {
-            key: "rank",
-            label: "Rank",
-            format: (data, index) => `${index + 1}`,
-            isVisible: () => true,
-        },
-        {
-            key: "strategy",
-            label: "Strategy",
-            format: (data) => data.strategyName,
-            isVisible: () => true,
-        },
-        {
-            key: "metric",
-            label: metric,
-            format: (data) => formatMetric(data.metricValue),
-            isVisible: () => true,
-        },
-        {
-            key: "totalSignals",
-            label: "Total Signals",
-            format: (data) => `${data.stats.totalSignals}`,
-            isVisible: () => true,
-        },
-        {
-            key: "winRate",
-            label: "Win Rate",
-            format: (data) => data.stats.winRate !== null
-                ? `${data.stats.winRate.toFixed(2)}%`
-                : "N/A",
-            isVisible: () => true,
-        },
-        {
-            key: "avgPnl",
-            label: "Avg PNL",
-            format: (data) => data.stats.avgPnl !== null
-                ? `${data.stats.avgPnl > 0 ? "+" : ""}${data.stats.avgPnl.toFixed(2)}%`
-                : "N/A",
-            isVisible: () => true,
-        },
-        {
-            key: "totalPnl",
-            label: "Total PNL",
-            format: (data) => data.stats.totalPnl !== null
-                ? `${data.stats.totalPnl > 0 ? "+" : ""}${data.stats.totalPnl.toFixed(2)}%`
-                : "N/A",
-            isVisible: () => true,
-        },
-        {
-            key: "sharpeRatio",
-            label: "Sharpe Ratio",
-            format: (data) => data.stats.sharpeRatio !== null
-                ? `${data.stats.sharpeRatio.toFixed(3)}`
-                : "N/A",
-            isVisible: () => true,
-        },
-        {
-            key: "stdDev",
-            label: "Std Dev",
-            format: (data) => data.stats.stdDev !== null
-                ? `${data.stats.stdDev.toFixed(3)}%`
-                : "N/A",
-            isVisible: () => true,
-        },
-    ];
-}
-/**
- * Column configuration for PNL table.
- * Defines all columns for displaying closed signals across strategies.
- */
-const pnlColumns = [
-    {
-        key: "strategy",
-        label: "Strategy",
-        format: (data) => data.strategyName,
-        isVisible: () => true,
-    },
-    {
-        key: "signalId",
-        label: "Signal ID",
-        format: (data) => data.signalId,
-        isVisible: () => true,
-    },
-    {
-        key: "symbol",
-        label: "Symbol",
-        format: (data) => data.symbol,
-        isVisible: () => true,
-    },
-    {
-        key: "position",
-        label: "Position",
-        format: (data) => data.position.toUpperCase(),
-        isVisible: () => true,
-    },
-    {
-        key: "pnl",
-        label: "PNL (net)",
-        format: (data) => `${data.pnl > 0 ? "+" : ""}${data.pnl.toFixed(2)}%`,
-        isVisible: () => true,
-    },
-    {
-        key: "closeReason",
-        label: "Close Reason",
-        format: (data) => data.closeReason,
-        isVisible: () => true,
-    },
-    {
-        key: "openTime",
-        label: "Open Time",
-        format: (data) => new Date(data.openTime).toISOString(),
-        isVisible: () => true,
-    },
-    {
-        key: "closeTime",
-        label: "Close Time",
-        format: (data) => new Date(data.closeTime).toISOString(),
-        isVisible: () => true,
-    },
-];
 /**
  * Storage class for accumulating walker results.
  * Maintains a list of all strategy results and provides methods to generate reports.
@@ -8397,7 +9042,7 @@ let ReportStorage$2 = class ReportStorage {
         this._strategyResults.unshift({
             strategyName: data.strategyName,
             stats: data.stats,
-            metricValue: data.metricValue,
+            metricValue: isUnsafe$1(data.metricValue) ? null : data.metricValue,
         });
     }
     /**
@@ -8430,11 +9075,11 @@ let ReportStorage$2 = class ReportStorage {
      * Generates comparison table for top N strategies (View).
      * Sorts strategies by metric value and formats as markdown table.
      *
-     * @param metric - Metric being optimized
      * @param topN - Number of top strategies to include (default: 10)
+     * @param columns - Column configuration for formatting the strategy comparison table
      * @returns Markdown formatted comparison table
      */
-    getComparisonTable(metric, topN = 10) {
+    async getComparisonTable(topN = 10, columns = COLUMN_CONFIG.walker_strategy_columns) {
         if (this._strategyResults.length === 0) {
             return "No strategy results available.";
         }
@@ -8447,13 +9092,17 @@ let ReportStorage$2 = class ReportStorage {
         // Take top N strategies
         const topStrategies = sortedResults.slice(0, topN);
         // Get columns configuration
-        const columns = createStrategyColumns(metric);
-        const visibleColumns = columns.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         // Build table header
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
         // Build table rows
-        const rows = topStrategies.map((result, index) => visibleColumns.map((col) => col.format(result, index)));
+        const rows = await Promise.all(topStrategies.map(async (result, index) => Promise.all(visibleColumns.map((col) => col.format(result, index)))));
         const tableData = [header, separator, ...rows];
         return tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
     }
@@ -8461,9 +9110,10 @@ let ReportStorage$2 = class ReportStorage {
      * Generates PNL table showing all closed signals across all strategies (View).
      * Collects all signals from all strategies and formats as markdown table.
      *
+     * @param columns - Column configuration for formatting the PNL table
      * @returns Markdown formatted PNL table
      */
-    getPnlTable() {
+    async getPnlTable(columns = COLUMN_CONFIG.walker_pnl_columns) {
         if (this._strategyResults.length === 0) {
             return "No strategy results available.";
         }
@@ -8487,11 +9137,16 @@ let ReportStorage$2 = class ReportStorage {
             return "No closed signals available.";
         }
         // Build table header
-        const visibleColumns = pnlColumns.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
         // Build table rows
-        const rows = allSignals.map((signal) => visibleColumns.map((col) => col.format(signal)));
+        const rows = await Promise.all(allSignals.map(async (signal, index) => Promise.all(visibleColumns.map((col) => col.format(signal, index)))));
         const tableData = [header, separator, ...rows];
         return tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
     }
@@ -8502,9 +9157,11 @@ let ReportStorage$2 = class ReportStorage {
      * @param symbol - Trading symbol
      * @param metric - Metric being optimized
      * @param context - Context with exchangeName and frameName
+     * @param strategyColumns - Column configuration for strategy comparison table
+     * @param pnlColumns - Column configuration for PNL table
      * @returns Markdown formatted report with all results
      */
-    async getReport(symbol, metric, context) {
+    async getReport(symbol, metric, context, strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) {
         const results = await this.getData(symbol, metric, context);
         // Get total signals for best strategy
         const bestStrategySignals = results.bestStats?.totalSignals ?? 0;
@@ -8524,11 +9181,11 @@ let ReportStorage$2 = class ReportStorage {
             "",
             "## Top Strategies Comparison",
             "",
-            this.getComparisonTable(metric, 10),
+            await this.getComparisonTable(10, strategyColumns),
             "",
             "## All Signals (PNL Table)",
             "",
-            this.getPnlTable(),
+            await this.getPnlTable(pnlColumns),
             "",
             "**Note:** Higher values are better for all metrics except Standard Deviation (lower is better)."
         ].join("\n");
@@ -8540,9 +9197,11 @@ let ReportStorage$2 = class ReportStorage {
      * @param metric - Metric being optimized
      * @param context - Context with exchangeName and frameName
      * @param path - Directory path to save report (default: "./dump/walker")
+     * @param strategyColumns - Column configuration for strategy comparison table
+     * @param pnlColumns - Column configuration for PNL table
      */
-    async dump(symbol, metric, context, path = "./dump/walker") {
-        const markdown = await this.getReport(symbol, metric, context);
+    async dump(symbol, metric, context, path = "./dump/walker", strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) {
+        const markdown = await this.getReport(symbol, metric, context, strategyColumns, pnlColumns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -8635,6 +9294,8 @@ class WalkerMarkdownService {
          * @param symbol - Trading symbol
          * @param metric - Metric being optimized
          * @param context - Context with exchangeName and frameName
+         * @param strategyColumns - Column configuration for strategy comparison table
+         * @param pnlColumns - Column configuration for PNL table
          * @returns Markdown formatted report string
          *
          * @example
@@ -8644,7 +9305,7 @@ class WalkerMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (walkerName, symbol, metric, context) => {
+        this.getReport = async (walkerName, symbol, metric, context, strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) => {
             this.loggerService.log("walkerMarkdownService getReport", {
                 walkerName,
                 symbol,
@@ -8652,7 +9313,7 @@ class WalkerMarkdownService {
                 context,
             });
             const storage = this.getStorage(walkerName);
-            return storage.getReport(symbol, metric, context);
+            return storage.getReport(symbol, metric, context, strategyColumns, pnlColumns);
         };
         /**
          * Saves walker report to disk.
@@ -8664,6 +9325,8 @@ class WalkerMarkdownService {
          * @param metric - Metric being optimized
          * @param context - Context with exchangeName and frameName
          * @param path - Directory path to save report (default: "./dump/walker")
+         * @param strategyColumns - Column configuration for strategy comparison table
+         * @param pnlColumns - Column configuration for PNL table
          *
          * @example
          * ```typescript
@@ -8676,7 +9339,7 @@ class WalkerMarkdownService {
          * await service.dump("my-walker", "BTCUSDT", "sharpeRatio", { exchangeName: "binance", frameName: "1d" }, "./custom/path");
          * ```
          */
-        this.dump = async (walkerName, symbol, metric, context, path = "./dump/walker") => {
+        this.dump = async (walkerName, symbol, metric, context, path = "./dump/walker", strategyColumns = COLUMN_CONFIG.walker_strategy_columns, pnlColumns = COLUMN_CONFIG.walker_pnl_columns) => {
             this.loggerService.log("walkerMarkdownService dump", {
                 walkerName,
                 symbol,
@@ -8685,7 +9348,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.
@@ -8751,80 +9414,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 ? str(data.totalPnl, "%+.2f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "sharpeRatio",
-        label: "Sharpe",
-        format: (data) => data.sharpeRatio !== null ? str(data.sharpeRatio, "%.2f") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "profitFactor",
-        label: "PF",
-        format: (data) => data.profitFactor !== null ? str(data.profitFactor, "%.2f") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "expectancy",
-        label: "Expect",
-        format: (data) => data.expectancy !== null ? str(data.expectancy, "%+.2f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "winRate",
-        label: "WR",
-        format: (data) => data.winRate !== null ? str(data.winRate, "%.1f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "avgWin",
-        label: "Avg Win",
-        format: (data) => data.avgWin !== null ? str(data.avgWin, "%+.2f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "avgLoss",
-        label: "Avg Loss",
-        format: (data) => data.avgLoss !== null ? str(data.avgLoss, "%+.2f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "maxDrawdown",
-        label: "Max DD",
-        format: (data) => data.maxDrawdown !== null ? str(-data.maxDrawdown, "%.2f%%") : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "maxWinStreak",
-        label: "W Streak",
-        format: (data) => data.maxWinStreak.toString(),
-        isVisible: () => true,
-    },
-    {
-        key: "maxLossStreak",
-        label: "L Streak",
-        format: (data) => data.maxLossStreak.toString(),
-        isVisible: () => true,
-    },
-    {
-        key: "totalTrades",
-        label: "Trades",
-        format: (data) => data.totalTrades.toString(),
-        isVisible: () => true,
-    },
-];
 /** Maximum number of signals to store per symbol in heatmap reports */
 const MAX_EVENTS$2 = 250;
 /**
@@ -9059,9 +9648,10 @@ class HeatmapStorage {
      * Generates markdown report with portfolio heatmap table (View).
      *
      * @param strategyName - Strategy name for report title
+     * @param columns - Column configuration for formatting the table
      * @returns Promise resolving to markdown formatted report string
      */
-    async getReport(strategyName) {
+    async getReport(strategyName, columns = COLUMN_CONFIG.heat_columns) {
         const data = await this.getData();
         if (data.symbols.length === 0) {
             return [
@@ -9070,10 +9660,15 @@ class HeatmapStorage {
                 "*No data available*"
             ].join("\n");
         }
-        const visibleColumns = columns$2.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = data.symbols.map((row) => visibleColumns.map((col) => col.format(row)));
+        const rows = await Promise.all(data.symbols.map(async (row, index) => Promise.all(visibleColumns.map((col) => col.format(row, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -9089,9 +9684,10 @@ class HeatmapStorage {
      *
      * @param strategyName - Strategy name for filename
      * @param path - Directory path to save report (default: "./dump/heatmap")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(strategyName, path = "./dump/heatmap") {
-        const markdown = await this.getReport(strategyName);
+    async dump(strategyName, path = "./dump/heatmap", columns = COLUMN_CONFIG.heat_columns) {
+        const markdown = await this.getReport(strategyName, columns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -9188,6 +9784,7 @@ class HeatMarkdownService {
          * Generates markdown report with portfolio heatmap table for a strategy.
          *
          * @param strategyName - Strategy name to generate heatmap report for
+         * @param columns - Column configuration for formatting the table
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -9207,12 +9804,12 @@ class HeatMarkdownService {
          * // ...
          * ```
          */
-        this.getReport = async (strategyName) => {
+        this.getReport = async (strategyName, columns = COLUMN_CONFIG.heat_columns) => {
             this.loggerService.log(HEATMAP_METHOD_NAME_GET_REPORT, {
                 strategyName,
             });
             const storage = this.getStorage(strategyName);
-            return storage.getReport(strategyName);
+            return storage.getReport(strategyName, columns);
         };
         /**
          * Saves heatmap report to disk for a strategy.
@@ -9222,6 +9819,7 @@ class HeatMarkdownService {
          *
          * @param strategyName - Strategy name to save heatmap report for
          * @param path - Optional directory path to save report (default: "./dump/heatmap")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -9234,13 +9832,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.
@@ -11094,6 +11692,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 = {
@@ -11118,7 +11719,7 @@ const HANDLE_PROFIT_FN = async (symbol, data, currentPrice, revenuePercent, back
         }
     }
     if (shouldPersist) {
-        await self._persistState(symbol, backtest);
+        await self._persistState(symbol, data.strategyName);
     }
 };
 /**
@@ -11140,6 +11741,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 = {
@@ -11165,7 +11769,7 @@ const HANDLE_LOSS_FN = async (symbol, data, currentPrice, lossPercent, backtest,
         }
     }
     if (shouldPersist) {
-        await self._persistState(symbol, backtest);
+        await self._persistState(symbol, data.strategyName);
     }
 };
 /**
@@ -11174,15 +11778,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),
@@ -11192,6 +11810,7 @@ const WAIT_FOR_INIT_FN = async (symbol, self) => {
     }
     self.params.logger.info("ClientPartial restored state", {
         symbol,
+        strategyName,
         signalCount: Object.keys(partialData).length,
     });
 };
@@ -11270,23 +11889,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 = singleshot(async (symbol) => await WAIT_FOR_INIT_FN(symbol, this));
-        this._states = new Map();
+        this.waitForInit = singleshot(async (symbol, strategyName) => await WAIT_FOR_INIT_FN(symbol, strategyName, this));
     }
     /**
      * Persists current partial state to disk.
@@ -11299,13 +11919,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.");
         }
@@ -11316,7 +11938,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.
@@ -11437,8 +12059,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);
     }
 }
 
@@ -11533,15 +12158,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 = memoize(([signalId]) => `${signalId}`, () => {
+        this.getPartial = 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,
             });
@@ -11569,8 +12196,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);
         };
         /**
@@ -11596,8 +12223,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);
         };
         /**
@@ -11618,75 +12245,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;
 /**
@@ -11776,9 +12349,10 @@ let ReportStorage$1 = class ReportStorage {
      *
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all events
      */
-    async getReport(symbol, strategyName) {
+    async getReport(symbol, strategyName, columns = COLUMN_CONFIG.partial_columns) {
         const stats = await this.getData();
         if (stats.totalEvents === 0) {
             return [
@@ -11787,10 +12361,15 @@ let ReportStorage$1 = class ReportStorage {
                 "No partial profit/loss events recorded yet."
             ].join("\n");
         }
-        const visibleColumns = columns$1.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
+        const rows = await Promise.all(this._eventList.map(async (event, index) => Promise.all(visibleColumns.map((col) => col.format(event, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -11809,9 +12388,10 @@ let ReportStorage$1 = class ReportStorage {
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/partial")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(symbol, strategyName, path = "./dump/partial") {
-        const markdown = await this.getReport(symbol, strategyName);
+    async dump(symbol, strategyName, path = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) {
+        const markdown = await this.getReport(symbol, strategyName, columns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -11922,6 +12502,7 @@ class PartialMarkdownService {
          *
          * @param symbol - Trading pair symbol to generate report for
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
@@ -11931,13 +12512,13 @@ class PartialMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.partial_columns) => {
             this.loggerService.log("partialMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(symbol, strategyName);
+            return storage.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -11947,6 +12528,7 @@ class PartialMarkdownService {
          * @param symbol - Trading pair symbol to save report for
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/partial")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -11959,14 +12541,14 @@ class PartialMarkdownService {
          * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/partial") => {
+        this.dump = async (symbol, strategyName, path = "./dump/partial", columns = COLUMN_CONFIG.partial_columns) => {
             this.loggerService.log("partialMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(symbol, strategyName, path);
+            await storage.dump(symbol, strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
@@ -12426,92 +13008,6 @@ class ConfigValidationService {
     }
 }
 
-const columns = [
-    {
-        key: "symbol",
-        label: "Symbol",
-        format: (data) => data.symbol,
-        isVisible: () => true,
-    },
-    {
-        key: "strategyName",
-        label: "Strategy",
-        format: (data) => data.strategyName,
-        isVisible: () => true,
-    },
-    {
-        key: "signalId",
-        label: "Signal ID",
-        format: (data) => data.pendingSignal.id || "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "position",
-        label: "Position",
-        format: (data) => data.pendingSignal.position.toUpperCase(),
-        isVisible: () => true,
-    },
-    {
-        key: "note",
-        label: "Note",
-        format: (data) => toPlainString(data.pendingSignal.note ?? "N/A"),
-        isVisible: () => GLOBAL_CONFIG.CC_REPORT_SHOW_SIGNAL_NOTE,
-    },
-    {
-        key: "exchangeName",
-        label: "Exchange",
-        format: (data) => data.exchangeName,
-        isVisible: () => true,
-    },
-    {
-        key: "openPrice",
-        label: "Open Price",
-        format: (data) => data.pendingSignal.priceOpen !== undefined
-            ? `${data.pendingSignal.priceOpen.toFixed(8)} USD`
-            : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "takeProfit",
-        label: "Take Profit",
-        format: (data) => data.pendingSignal.priceTakeProfit !== undefined
-            ? `${data.pendingSignal.priceTakeProfit.toFixed(8)} USD`
-            : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "stopLoss",
-        label: "Stop Loss",
-        format: (data) => data.pendingSignal.priceStopLoss !== undefined
-            ? `${data.pendingSignal.priceStopLoss.toFixed(8)} USD`
-            : "N/A",
-        isVisible: () => true,
-    },
-    {
-        key: "currentPrice",
-        label: "Current Price",
-        format: (data) => `${data.currentPrice.toFixed(8)} USD`,
-        isVisible: () => true,
-    },
-    {
-        key: "activePositionCount",
-        label: "Active Positions",
-        format: (data) => data.activePositionCount.toString(),
-        isVisible: () => true,
-    },
-    {
-        key: "comment",
-        label: "Reason",
-        format: (data) => data.comment,
-        isVisible: () => true,
-    },
-    {
-        key: "timestamp",
-        label: "Timestamp",
-        format: (data) => new Date(data.timestamp).toISOString(),
-        isVisible: () => true,
-    },
-];
 /** Maximum number of events to store in risk reports */
 const MAX_EVENTS = 250;
 /**
@@ -12567,9 +13063,10 @@ class ReportStorage {
      *
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name
+     * @param columns - Column configuration for formatting the table
      * @returns Markdown formatted report with all events
      */
-    async getReport(symbol, strategyName) {
+    async getReport(symbol, strategyName, columns = COLUMN_CONFIG.risk_columns) {
         const stats = await this.getData();
         if (stats.totalRejections === 0) {
             return [
@@ -12578,10 +13075,15 @@ class ReportStorage {
                 "No risk rejections recorded yet.",
             ].join("\n");
         }
-        const visibleColumns = columns.filter((col) => col.isVisible());
+        const visibleColumns = [];
+        for (const col of columns) {
+            if (await col.isVisible()) {
+                visibleColumns.push(col);
+            }
+        }
         const header = visibleColumns.map((col) => col.label);
         const separator = visibleColumns.map(() => "---");
-        const rows = this._eventList.map((event) => visibleColumns.map((col) => col.format(event)));
+        const rows = await Promise.all(this._eventList.map(async (event, index) => Promise.all(visibleColumns.map((col) => col.format(event, index)))));
         const tableData = [header, separator, ...rows];
         const table = tableData.map((row) => `| ${row.join(" | ")} |`).join("\n");
         return [
@@ -12604,9 +13106,10 @@ class ReportStorage {
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name
      * @param path - Directory path to save report (default: "./dump/risk")
+     * @param columns - Column configuration for formatting the table
      */
-    async dump(symbol, strategyName, path = "./dump/risk") {
-        const markdown = await this.getReport(symbol, strategyName);
+    async dump(symbol, strategyName, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) {
+        const markdown = await this.getReport(symbol, strategyName, columns);
         try {
             const dir = join(process.cwd(), path);
             await mkdir(dir, { recursive: true });
@@ -12698,6 +13201,7 @@ class RiskMarkdownService {
          *
          * @param symbol - Trading pair symbol to generate report for
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Column configuration for formatting the table
          * @returns Markdown formatted report string with table of all events
          *
          * @example
@@ -12707,13 +13211,13 @@ class RiskMarkdownService {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns = COLUMN_CONFIG.risk_columns) => {
             this.loggerService.log("riskMarkdownService getReport", {
                 symbol,
                 strategyName,
             });
             const storage = this.getStorage(symbol, strategyName);
-            return storage.getReport(symbol, strategyName);
+            return storage.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves symbol-strategy report to disk.
@@ -12723,6 +13227,7 @@ class RiskMarkdownService {
          * @param symbol - Trading pair symbol to save report for
          * @param strategyName - Strategy name to save report for
          * @param path - Directory path to save report (default: "./dump/risk")
+         * @param columns - Column configuration for formatting the table
          *
          * @example
          * ```typescript
@@ -12735,14 +13240,14 @@ class RiskMarkdownService {
          * await service.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path = "./dump/risk") => {
+        this.dump = async (symbol, strategyName, path = "./dump/risk", columns = COLUMN_CONFIG.risk_columns) => {
             this.loggerService.log("riskMarkdownService dump", {
                 symbol,
                 strategyName,
                 path,
             });
             const storage = this.getStorage(symbol, strategyName);
-            await storage.dump(symbol, strategyName, path);
+            await storage.dump(symbol, strategyName, path, columns);
         };
         /**
          * Clears accumulated event data from storage.
@@ -12792,6 +13297,118 @@ class RiskMarkdownService {
     }
 }
 
+/**
+ * Service for validating column configurations to ensure consistency with ColumnModel interface
+ * and prevent invalid column definitions.
+ *
+ * Performs comprehensive validation on all column definitions in COLUMN_CONFIG:
+ * - **Required fields**: All columns must have key, label, format, and isVisible properties
+ * - **Unique keys**: All key values must be unique within each column collection
+ * - **Function validation**: format and isVisible must be callable functions
+ * - **Data types**: key and label must be non-empty strings
+ *
+ * @throws {Error} If any validation fails, throws with detailed breakdown of all errors
+ *
+ * @example
+ * ```typescript
+ * const validator = new ColumnValidationService();
+ * validator.validate(); // Throws if column configuration is invalid
+ * ```
+ *
+ * @example Validation failure output:
+ * ```
+ * Column configuration validation failed:
+ *   1. backtest_columns[0]: Missing required field "format"
+ *   2. heat_columns: Duplicate key "symbol" at indexes 1, 5
+ *   3. live_columns[3].isVisible must be a function, got "boolean"
+ * ```
+ */
+class ColumnValidationService {
+    constructor() {
+        /**
+         * @private
+         * @readonly
+         * Injected logger service instance
+         */
+        this.loggerService = inject(TYPES.loggerService);
+        /**
+         * Validates all column configurations in COLUMN_CONFIG for structural correctness.
+         *
+         * Checks:
+         * 1. All required fields (key, label, format, isVisible) are present in each column
+         * 2. key and label are non-empty strings
+         * 3. format and isVisible are functions (not other types)
+         * 4. All keys are unique within each column collection
+         *
+         * @throws Error if configuration is invalid
+         */
+        this.validate = () => {
+            this.loggerService.log("columnValidationService validate");
+            const errors = [];
+            // Iterate through all column collections in COLUMN_CONFIG
+            for (const [configKey, columns] of Object.entries(COLUMN_CONFIG)) {
+                if (!Array.isArray(columns)) {
+                    errors.push(`${configKey} is not an array, got ${typeof columns}`);
+                    continue;
+                }
+                // Track keys for uniqueness check
+                const keyMap = new Map();
+                // Validate each column in the collection
+                columns.forEach((column, index) => {
+                    if (!column || typeof column !== "object") {
+                        errors.push(`${configKey}[${index}]: Column must be an object, got ${typeof column}`);
+                        return;
+                    }
+                    // Check for all required fields
+                    const requiredFields = ["key", "label", "format", "isVisible"];
+                    for (const field of requiredFields) {
+                        if (!(field in column)) {
+                            errors.push(`${configKey}[${index}]: Missing required field "${field}"`);
+                        }
+                    }
+                    // Validate key and label are non-empty strings
+                    if (typeof column.key !== "string" || column.key.trim() === "") {
+                        errors.push(`${configKey}[${index}].key must be a non-empty string, got ${typeof column.key === "string" ? `"${column.key}"` : typeof column.key}`);
+                    }
+                    else {
+                        // Track key for uniqueness check
+                        if (!keyMap.has(column.key)) {
+                            keyMap.set(column.key, []);
+                        }
+                        keyMap.get(column.key).push(index);
+                    }
+                    if (typeof column.label !== "string" || column.label.trim() === "") {
+                        errors.push(`${configKey}[${index}].label must be a non-empty string, got ${typeof column.label === "string" ? `"${column.label}"` : typeof column.label}`);
+                    }
+                    // Validate format is a function
+                    if (typeof column.format !== "function") {
+                        errors.push(`${configKey}[${index}].format must be a function, got "${typeof column.format}"`);
+                    }
+                    // Validate isVisible is a function
+                    if (typeof column.isVisible !== "function") {
+                        errors.push(`${configKey}[${index}].isVisible must be a function, got "${typeof column.isVisible}"`);
+                    }
+                });
+                // Check for duplicate keys
+                for (const [key, indexes] of keyMap.entries()) {
+                    if (indexes.length > 1) {
+                        errors.push(`${configKey}: Duplicate key "${key}" at indexes ${indexes.join(", ")}`);
+                    }
+                }
+            }
+            // Throw aggregated errors if any
+            if (errors.length > 0) {
+                const errorMessage = `Column configuration validation failed:\n${errors
+                    .map((e, i) => `  ${i + 1}. ${e}`)
+                    .join("\n")}`;
+                this.loggerService.warn(errorMessage);
+                throw new Error(errorMessage);
+            }
+            this.loggerService.log("columnValidationService validation passed");
+        };
+    }
+}
+
 {
     provide(TYPES.loggerService, () => new LoggerService());
 }
@@ -12863,6 +13480,7 @@ class RiskMarkdownService {
     provide(TYPES.riskValidationService, () => new RiskValidationService());
     provide(TYPES.optimizerValidationService, () => new OptimizerValidationService());
     provide(TYPES.configValidationService, () => new ConfigValidationService());
+    provide(TYPES.columnValidationService, () => new ColumnValidationService());
 }
 {
     provide(TYPES.optimizerTemplateService, () => new OptimizerTemplateService());
@@ -12939,6 +13557,7 @@ const validationServices = {
     riskValidationService: inject(TYPES.riskValidationService),
     optimizerValidationService: inject(TYPES.optimizerValidationService),
     configValidationService: inject(TYPES.configValidationService),
+    columnValidationService: inject(TYPES.columnValidationService),
 };
 const templateServices = {
     optimizerTemplateService: inject(TYPES.optimizerTemplateService),
@@ -13038,6 +13657,77 @@ function getConfig() {
 function getDefaultConfig() {
     return DEFAULT_CONFIG;
 }
+/**
+ * Sets custom column configurations for markdown report generation.
+ *
+ * Allows overriding default column definitions for any report type.
+ * All columns are validated before assignment to ensure structural correctness.
+ *
+ * @param columns - Partial column configuration object to override default column settings
+ * @param _unsafe - Skip column validations - required for testbed
+ *
+ * @example
+ * ```typescript
+ * setColumns({
+ *   backtest_columns: [
+ *     {
+ *       key: "customId",
+ *       label: "Custom ID",
+ *       format: (data) => data.signal.id,
+ *       isVisible: () => true
+ *     }
+ *   ],
+ * });
+ * ```
+ *
+ * @throws {Error} If column configuration is invalid
+ */
+function setColumns(columns, _unsafe) {
+    const prevConfig = Object.assign({}, COLUMN_CONFIG);
+    try {
+        Object.assign(COLUMN_CONFIG, columns);
+        !_unsafe && backtest$1.columnValidationService.validate();
+    }
+    catch (error) {
+        console.warn(`backtest-kit setColumns failed: ${getErrorMessage(error)}`, columns);
+        Object.assign(COLUMN_CONFIG, prevConfig);
+        throw error;
+    }
+}
+/**
+ * Retrieves a copy of the current column configuration for markdown report generation.
+ *
+ * Returns a shallow copy of the current COLUMN_CONFIG to prevent accidental mutations.
+ * Use this to inspect the current column definitions without modifying them.
+ *
+ * @returns {ColumnConfig} A copy of the current column configuration object
+ *
+ * @example
+ * ```typescript
+ * const currentColumns = getColumns();
+ * console.log(currentColumns.backtest_columns.length);
+ * ```
+ */
+function getColumns() {
+    return Object.assign({}, COLUMN_CONFIG);
+}
+/**
+ * Retrieves the default column configuration object for markdown report generation.
+ *
+ * Returns a reference to the default column definitions with all preset values.
+ * Use this to see what column options are available and their default definitions.
+ *
+ * @returns {ColumnConfig} The default column configuration object
+ *
+ * @example
+ * ```typescript
+ * const defaultColumns = getDefaultColumns();
+ * console.log(defaultColumns.backtest_columns);
+ * ```
+ */
+function getDefaultColumns() {
+    return DEFAULT_COLUMNS;
+}
 
 const ADD_STRATEGY_METHOD_NAME = "add.addStrategy";
 const ADD_EXCHANGE_METHOD_NAME = "add.addExchange";
@@ -14917,12 +15607,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);
         };
@@ -14953,9 +15643,9 @@ class BacktestInstance {
             });
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(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;
@@ -14995,7 +15685,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.
@@ -15023,6 +15713,7 @@ class BacktestInstance {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15032,12 +15723,12 @@ class BacktestInstance {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(BACKTEST_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
             });
-            return await backtest$1.backtestMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.backtestMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15045,6 +15736,7 @@ class BacktestInstance {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/backtest")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15056,13 +15748,13 @@ class BacktestInstance {
          * await instance.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(BACKTEST_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
                 path,
             });
-            await backtest$1.backtestMarkdownService.dump(symbol, strategyName, path);
+            await backtest$1.backtestMarkdownService.dump(symbol, strategyName, path, columns);
         };
     }
 }
@@ -15201,6 +15893,7 @@ class BacktestUtils {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15209,7 +15902,7 @@ class BacktestUtils {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -15217,7 +15910,7 @@ class BacktestUtils {
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, BACKTEST_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, strategyName);
-            return await instance.getReport(symbol, strategyName);
+            return await instance.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15225,6 +15918,7 @@ class BacktestUtils {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/backtest")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15235,7 +15929,7 @@ class BacktestUtils {
          * await Backtest.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.strategyValidationService.validate(strategyName, BACKTEST_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -15243,7 +15937,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.
@@ -15417,12 +16111,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);
         };
@@ -15453,9 +16147,9 @@ class LiveInstance {
             });
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(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;
@@ -15495,7 +16189,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.
@@ -15523,6 +16217,7 @@ class LiveInstance {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15532,12 +16227,12 @@ class LiveInstance {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(LIVE_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
             });
-            return await backtest$1.liveMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.liveMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15545,6 +16240,7 @@ class LiveInstance {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/live")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15556,13 +16252,13 @@ class LiveInstance {
          * await instance.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(LIVE_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
                 path,
             });
-            await backtest$1.liveMarkdownService.dump(symbol, strategyName, path);
+            await backtest$1.liveMarkdownService.dump(symbol, strategyName, path, columns);
         };
     }
 }
@@ -15712,6 +16408,7 @@ class LiveUtils {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15720,7 +16417,7 @@ class LiveUtils {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_GET_REPORT);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -15728,7 +16425,7 @@ class LiveUtils {
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_GET_REPORT));
             }
             const instance = this._getInstance(symbol, strategyName);
-            return await instance.getReport(symbol, strategyName);
+            return await instance.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15736,6 +16433,7 @@ class LiveUtils {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/live")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15746,7 +16444,7 @@ class LiveUtils {
          * await Live.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.strategyValidationService.validate(strategyName, LIVE_METHOD_NAME_DUMP);
             {
                 const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
@@ -15754,7 +16452,7 @@ class LiveUtils {
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, LIVE_METHOD_NAME_DUMP));
             }
             const instance = this._getInstance(symbol, strategyName);
-            return await instance.dump(symbol, strategyName, path);
+            return await instance.dump(symbol, strategyName, path, columns);
         };
         /**
          * Lists all active live trading instances with their current status.
@@ -15853,6 +16551,7 @@ class ScheduleUtils {
          *
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to generate report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -15861,7 +16560,7 @@ class ScheduleUtils {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_GET_REPORT, {
                 symbol,
                 strategyName,
@@ -15872,7 +16571,7 @@ class ScheduleUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.scheduleMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.scheduleMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Saves strategy report to disk.
@@ -15880,6 +16579,7 @@ class ScheduleUtils {
          * @param symbol - Trading pair symbol
          * @param strategyName - Strategy name to save report for
          * @param path - Optional directory path to save report (default: "./dump/schedule")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -15890,7 +16590,7 @@ class ScheduleUtils {
          * await Schedule.dump("BTCUSDT", "my-strategy", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(SCHEDULE_METHOD_NAME_DUMP, {
                 symbol,
                 strategyName,
@@ -15902,7 +16602,7 @@ class ScheduleUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, SCHEDULE_METHOD_NAME_DUMP));
             }
-            await backtest$1.scheduleMarkdownService.dump(symbol, strategyName, path);
+            await backtest$1.scheduleMarkdownService.dump(symbol, strategyName, path, columns);
         };
     }
 }
@@ -16002,6 +16702,7 @@ class Performance {
      *
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name to generate report for
+     * @param columns - Optional columns configuration for the report
      * @returns Markdown formatted report string
      *
      * @example
@@ -16014,14 +16715,14 @@ class Performance {
      * await fs.writeFile("performance-report.md", markdown);
      * ```
      */
-    static async getReport(symbol, strategyName) {
+    static async getReport(symbol, strategyName, columns) {
         backtest$1.strategyValidationService.validate(strategyName, PERFORMANCE_METHOD_NAME_GET_REPORT);
         {
             const { riskName, riskList } = backtest$1.strategySchemaService.get(strategyName);
             riskName && backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT);
             riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PERFORMANCE_METHOD_NAME_GET_REPORT));
         }
-        return backtest$1.performanceMarkdownService.getReport(symbol, strategyName);
+        return backtest$1.performanceMarkdownService.getReport(symbol, strategyName, columns);
     }
     /**
      * Saves performance report to disk.
@@ -16032,6 +16733,7 @@ class Performance {
      * @param symbol - Trading pair symbol
      * @param strategyName - Strategy name to save report for
      * @param path - Optional custom directory path
+     * @param columns - Optional columns configuration for the report
      *
      * @example
      * ```typescript
@@ -16042,14 +16744,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);
     }
 }
 
@@ -16191,12 +16893,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, {
@@ -16232,8 +16935,12 @@ class WalkerInstance {
             this.task(symbol, context).catch((error) => exitEmitter.next(new Error(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({
@@ -16278,7 +16985,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 });
             }
         };
         /**
@@ -16311,6 +17018,8 @@ class WalkerInstance {
          *
          * @param symbol - Trading symbol
          * @param walkerName - Walker name to generate report for
+         * @param strategyColumns - Optional strategy columns configuration
+         * @param pnlColumns - Optional PNL columns configuration
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -16320,7 +17029,7 @@ class WalkerInstance {
          * console.log(markdown);
          * ```
          */
-        this.getReport = async (symbol, walkerName) => {
+        this.getReport = async (symbol, walkerName, strategyColumns, pnlColumns) => {
             backtest$1.loggerService.info(WALKER_METHOD_NAME_GET_REPORT, {
                 symbol,
                 walkerName,
@@ -16329,7 +17038,7 @@ class WalkerInstance {
             return await backtest$1.walkerMarkdownService.getReport(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
-            });
+            }, strategyColumns, pnlColumns);
         };
         /**
          * Saves walker report to disk.
@@ -16337,6 +17046,8 @@ class WalkerInstance {
          * @param symbol - Trading symbol
          * @param walkerName - Walker name to save report for
          * @param path - Optional directory path to save report (default: "./dump/walker")
+         * @param strategyColumns - Optional strategy columns configuration
+         * @param pnlColumns - Optional PNL columns configuration
          *
          * @example
          * ```typescript
@@ -16348,7 +17059,7 @@ class WalkerInstance {
          * await instance.dump("BTCUSDT", "my-walker", "./custom/path");
          * ```
          */
-        this.dump = async (symbol, walkerName, path) => {
+        this.dump = async (symbol, walkerName, path, strategyColumns, pnlColumns) => {
             backtest$1.loggerService.info(WALKER_METHOD_NAME_DUMP, {
                 symbol,
                 walkerName,
@@ -16358,7 +17069,7 @@ class WalkerInstance {
             await backtest$1.walkerMarkdownService.dump(walkerName, symbol, walkerSchema.metric || "sharpeRatio", {
                 exchangeName: walkerSchema.exchangeName,
                 frameName: walkerSchema.frameName,
-            }, path);
+            }, path, strategyColumns, pnlColumns);
         };
     }
 }
@@ -16403,8 +17114,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);
@@ -16436,8 +17149,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);
@@ -16471,8 +17186,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);
@@ -16496,8 +17213,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);
@@ -16507,6 +17226,8 @@ class WalkerUtils {
          *
          * @param symbol - Trading symbol
          * @param walkerName - Walker name to generate report for
+         * @param strategyColumns - Optional strategy columns configuration
+         * @param pnlColumns - Optional PNL columns configuration
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -16515,17 +17236,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.
@@ -16533,6 +17256,8 @@ class WalkerUtils {
          * @param symbol - Trading symbol
          * @param walkerName - Walker name to save report for
          * @param path - Optional directory path to save report (default: "./dump/walker")
+         * @param strategyColumns - Optional strategy columns configuration
+         * @param pnlColumns - Optional PNL columns configuration
          *
          * @example
          * ```typescript
@@ -16543,17 +17268,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.
@@ -16659,6 +17386,7 @@ class HeatUtils {
          * Symbols are sorted by Total PNL descending.
          *
          * @param strategyName - Strategy name to generate heatmap report for
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -16677,7 +17405,7 @@ class HeatUtils {
          * // ...
          * ```
          */
-        this.getReport = async (strategyName) => {
+        this.getReport = async (strategyName, columns) => {
             backtest$1.loggerService.info(HEAT_METHOD_NAME_GET_REPORT, { strategyName });
             backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_GET_REPORT);
             {
@@ -16685,7 +17413,7 @@ class HeatUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.heatMarkdownService.getReport(strategyName);
+            return await backtest$1.heatMarkdownService.getReport(strategyName, columns);
         };
         /**
          * Saves heatmap report to disk for a strategy.
@@ -16695,6 +17423,7 @@ class HeatUtils {
          *
          * @param strategyName - Strategy name to save heatmap report for
          * @param path - Optional directory path to save report (default: "./dump/heatmap")
+         * @param columns - Optional columns configuration for the report
          *
          * @example
          * ```typescript
@@ -16705,7 +17434,7 @@ class HeatUtils {
          * await Heat.dump("my-strategy", "./reports");
          * ```
          */
-        this.dump = async (strategyName, path) => {
+        this.dump = async (strategyName, path, columns) => {
             backtest$1.loggerService.info(HEAT_METHOD_NAME_DUMP, { strategyName, path });
             backtest$1.strategyValidationService.validate(strategyName, HEAT_METHOD_NAME_DUMP);
             {
@@ -16713,7 +17442,7 @@ class HeatUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, HEAT_METHOD_NAME_DUMP));
             }
-            await backtest$1.heatMarkdownService.dump(strategyName, path);
+            await backtest$1.heatMarkdownService.dump(strategyName, path, columns);
         };
     }
 }
@@ -17013,7 +17742,7 @@ class PartialUtils {
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
-         * @returns Promise resolving to PartialStatistics object with counts and event list
+         * @returns Promise resolving to PartialStatisticsModel object with counts and event list
          *
          * @example
          * ```typescript
@@ -17057,6 +17786,7 @@ class PartialUtils {
          *
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
+         * @param columns - Optional columns configuration for the report
          * @returns Promise resolving to markdown formatted report string
          *
          * @example
@@ -17077,7 +17807,7 @@ class PartialUtils {
          * // **Loss events:** 1
          * ```
          */
-        this.getReport = async (symbol, strategyName) => {
+        this.getReport = async (symbol, strategyName, columns) => {
             backtest$1.loggerService.info(PARTIAL_METHOD_NAME_GET_REPORT, { symbol, strategyName });
             backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_GET_REPORT);
             {
@@ -17085,7 +17815,7 @@ class PartialUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_GET_REPORT));
             }
-            return await backtest$1.partialMarkdownService.getReport(symbol, strategyName);
+            return await backtest$1.partialMarkdownService.getReport(symbol, strategyName, columns);
         };
         /**
          * Generates and saves markdown report to file.
@@ -17102,6 +17832,7 @@ class PartialUtils {
          * @param symbol - Trading pair symbol (e.g., "BTCUSDT")
          * @param strategyName - Strategy name (e.g., "my-strategy")
          * @param path - Output directory path (default: "./dump/partial")
+         * @param columns - Optional columns configuration for the report
          * @returns Promise that resolves when file is written
          *
          * @example
@@ -17118,7 +17849,7 @@ class PartialUtils {
          * }
          * ```
          */
-        this.dump = async (symbol, strategyName, path) => {
+        this.dump = async (symbol, strategyName, path, columns) => {
             backtest$1.loggerService.info(PARTIAL_METHOD_NAME_DUMP, { symbol, strategyName, path });
             backtest$1.strategyValidationService.validate(strategyName, PARTIAL_METHOD_NAME_DUMP);
             {
@@ -17126,7 +17857,7 @@ class PartialUtils {
                 riskName && backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP);
                 riskList && riskList.forEach((riskName) => backtest$1.riskValidationService.validate(riskName, PARTIAL_METHOD_NAME_DUMP));
             }
-            await backtest$1.partialMarkdownService.dump(symbol, strategyName, path);
+            await backtest$1.partialMarkdownService.dump(symbol, strategyName, path, columns);
         };
     }
 }
@@ -17227,4 +17958,4 @@ class ConstantUtils {
  */
 const Constant = new ConstantUtils();
 
-export { Backtest, Constant, ExecutionContextService, Heat, Live, MethodContextService, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getConfig, getDate, getDefaultConfig, getMode, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setConfig, setLogger };
+export { Backtest, Constant, ExecutionContextService, Heat, Live, MethodContextService, Optimizer, Partial, Performance, PersistBase, PersistPartialAdapter, PersistRiskAdapter, PersistScheduleAdapter, PersistSignalAdapter, PositionSize, Risk, Schedule, Walker, addExchange, addFrame, addOptimizer, addRisk, addSizing, addStrategy, addWalker, dumpSignal, emitters, formatPrice, formatQuantity, getAveragePrice, getCandles, getColumns, getConfig, getDate, getDefaultColumns, getDefaultConfig, getMode, backtest as lib, listExchanges, listFrames, listOptimizers, listRisks, listSizings, listStrategies, listWalkers, listenBacktestProgress, listenDoneBacktest, listenDoneBacktestOnce, listenDoneLive, listenDoneLiveOnce, listenDoneWalker, listenDoneWalkerOnce, listenError, listenExit, listenOptimizerProgress, listenPartialLoss, listenPartialLossOnce, listenPartialProfit, listenPartialProfitOnce, listenPerformance, listenRisk, listenRiskOnce, listenSignal, listenSignalBacktest, listenSignalBacktestOnce, listenSignalLive, listenSignalLiveOnce, listenSignalOnce, listenValidation, listenWalker, listenWalkerComplete, listenWalkerOnce, listenWalkerProgress, setColumns, setConfig, setLogger };